10607476938

Committed 29 Aug 2024 02:11AM UTC coverage: 31.933% (-0.004%) from 31.937%

Build # 10607476938

Build Type

Pull #9663

github

Committed by

web-flow

Commit Message

Merge 27bdf4079 into a045d7828

Pull Request Pull Request #9663: Stream llm message chunks

Run Details

5023 of 41030 branches covered (12.24%)

Branch coverage included in aggregate %.

23 of 81 new or added lines in 7 files covered. (28.4%)

21 existing lines in 2 files now uncovered.

29325 of 66534 relevant lines covered (44.08%)

188.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.48

/packages/lesswrong/lib/vulcan-lib/components.tsx

import compose from 'lodash/flowRight';
import React, { forwardRef } from 'react';
import { withStyles } from '@material-ui/core/styles';
import { shallowEqual, shallowEqualExcept, debugShouldComponentUpdate } from '../utils/componentUtils';
import { isClient } from '../executionEnvironment';
import * as _ from 'underscore';

type ComparisonFn = (prev: any, next: any) => boolean
type ComparePropsDict = { [propName: string]: "default"|"shallow"|"ignore"|"deep"|ComparisonFn }
type AreEqualOption = ComparisonFn|ComparePropsDict|"auto"

// Options passed to registerComponent
interface ComponentOptions {
  // JSS styles for this component. These will generate class names, which will
  // be passed as an extra prop named "classes".
  styles?: any
  
  // Whether to ignore the presence of colors that don't come from the theme in
  // the component's stylesheet. Use for things that don't change color with
  // dark mode.
  allowNonThemeColors?: boolean,
  
  // Default is 0. If classes with overlapping attributes from two different
  // components' styles wind up applied to the same node, the one with higher
  // priority wins.
  stylePriority?: number,
  
  // Array of higher-order components that this component should be wrapped
  // with.
  hocs?: Array<any>
  
  // Determines what changes to props are considered relevant, for rerendering.
  // Takes either "auto" (meaning a shallow comparison of all props), a function
  // that takes before-and-after props, or an object where keys are names of
  // props, values are how those props are handled, and props that are not
  // mentioned are equality-compared. The options for handling a prop are a
  // function or one of:
  //   * ignore: Don't rerender this component on changes to this prop
  //   * shallow: Shallow-compare this prop (this is one level deeper than the
  //     shallow comparison of all props)
  //   * deep: Perform a deep comparison of before and after values of this
  //     prop. (Don't use on prop types that are or contain React components)
  areEqual?: AreEqualOption
  
  // If set, output console log messages reporting when this component is
  // rerendered, and which props changed to trigger it.
  debugRerenders?: boolean,
}

interface ComponentsTableEntry {
  name: string
  rawComponent: any
  hocs: Array<any>
  options?: ComponentOptions,
}

const componentsProxyHandler = {
  get: function(obj: {}, prop: string) {
    if (prop === "__isProxy") {
      return true;
    } else if (prop in PreparedComponents) {
      return PreparedComponents[prop];
    } else {
      return prepareComponent(prop);
    }
  }
}

/**
 * Acts like a mapping from component-name to component, based on
 * registerComponents calls. Lazily loads those components when you dereference,
 * using a proxy.
 */
export const Components: ComponentTypes = new Proxy({} as any, componentsProxyHandler);

const PreparedComponents: Record<string,any> = {};

// storage for infos about components
export const ComponentsTable: Record<string, ComponentsTableEntry> = {};

export const DeferredComponentsTable: Record<string,() => void> = {};

type EmailRenderContextType = {
  isEmailRender: boolean
}

export const EmailRenderContext = React.createContext<EmailRenderContextType|null>(null);

const classNameProxy = (prefix: string) => {
  return new Proxy({}, {
    get: function(obj: any, prop: any) {
      // Check that the prop is really a string. This isn't an error that comes
      // up normally, but apparently React devtools will try to query for non-
      // string properties sometimes when using the component debugger.
      if (typeof prop === "string")
        return prefix+prop;
      else
        return prefix+'invalid';
    }
  });
}

const addClassnames = (componentName: string, styles: any) => {
  const classesProxy = classNameProxy(componentName+'-');
  return (WrappedComponent: any) => forwardRef((props, ref) => {
    const emailRenderContext = React.useContext(EmailRenderContext);
    if (emailRenderContext?.isEmailRender) {
      const withStylesHoc = withStyles(styles, {name: componentName})
      const StylesWrappedComponent = withStylesHoc(WrappedComponent)
      return <StylesWrappedComponent {...props}/>
    }
    return <WrappedComponent ref={ref} {...props} classes={classesProxy}/>
  })
}

export const useStyles = (styles: (theme: ThemeType) => JssStyles, componentName: keyof ComponentTypes) => {
  return classNameProxy(componentName+'-');
};

// Register a component. Takes a name, a raw component, and ComponentOptions
// (see above). Components should be in their own file, imported with
// `importComponent`, and registered in that file; components that are
// registered this way can be accessed via the Components object and are lazy-
// loaded.
//
// Returns a dummy value--null, but coerced to a type that you can add to the
// ComponentTypes interface to type-check usages of the component in other
// files.
export function registerComponent<PropType>(name: string, rawComponent: React.ComponentType<PropType>,
  options?: ComponentOptions): React.ComponentType<Omit<PropType,"classes">>
{
  const { styles=null, hocs=[] } = options || {};
  if (styles) {
    if (isClient && window?.missingMainStylesheet) {
      hocs.push(withStyles(styles, {name: name}));
    } else {
      hocs.push(addClassnames(name, styles));
    }
  }
  
  rawComponent.displayName = name;
  
  if (name in ComponentsTable && ComponentsTable[name].rawComponent !== rawComponent) {
    throw new Error(`Two components with the same name: ${name}`);
  }
  
  // store the component in the table
  ComponentsTable[name] = {
    name,
    rawComponent,
    hocs,
    options,
  };
  
  // The Omit is a hacky way of ensuring that hocs props are omitted from the
  // ones required to be passed in by parent components. It doesn't work for
  // hocs that share prop names that overlap with actually passed-in props, like
  // `location`.
  return (null as any as React.ComponentType<Omit<PropType,"classes">>);
}

// If true, `importComponent` imports immediately (rather than deferring until
// first use) and checks that the file registered the components named, with a
// lot of log-spam.
const debugComponentImports = false;

export function importComponent(componentName: keyof ComponentTypes|Array<keyof ComponentTypes>, importFn: () => void) {
  if (Array.isArray(componentName)) {
    for (let name of componentName) {
      DeferredComponentsTable[name] = importFn;
    }
  } else {
    DeferredComponentsTable[componentName] = importFn;
  }
}

export function importAllComponents() {
  for (let componentName of Object.keys(DeferredComponentsTable)) {
    prepareComponent(componentName);
  }
}

export function prepareComponent(componentName: string): any
{
  if (componentName in PreparedComponents) {
    return PreparedComponents[componentName];
  } else if (componentName in ComponentsTable) {
    PreparedComponents[componentName] = getComponent(componentName);
    return PreparedComponents[componentName];
  } else if (componentName in DeferredComponentsTable) {
    DeferredComponentsTable[componentName]();
    if (!(componentName in ComponentsTable)) {
      throw new Error(`Import did not provide component ${componentName}`);
    }
    return prepareComponent(componentName);
  } else {
    // eslint-disable-next-line no-console
    console.error(`Missing component: ${componentName}`);
    return null;
  }
}

// Get a component registered with registerComponent, applying HoCs and other
// wrappings.
const getComponent = (name: string): any => {
  const componentMeta = ComponentsTable[name];
  if (!componentMeta) {
    throw new Error(`Component ${name} not registered.`);
  }
  
  const componentWithMemo = componentMeta.options?.areEqual
    ? memoizeComponent(componentMeta.options.areEqual, componentMeta.rawComponent, name, !!componentMeta.options.debugRerenders)
    : componentMeta.rawComponent;
  
  if (componentMeta.hocs && componentMeta.hocs.length) {
    const hocs = componentMeta.hocs.map(hoc => {
      if (!Array.isArray(hoc)) {
        if (typeof hoc !== 'function') {
          throw new Error(`In registered component ${name}, an hoc is of type ${typeof hoc}`);
        }
        return hoc;
      }
      const [actualHoc, ...args] = hoc;
      if (typeof actualHoc !== 'function') {
        throw new Error(`In registered component ${name}, an hoc is of type ${typeof actualHoc}`);
      }
      return actualHoc(...args);
    });
    // @ts-ignore
    return compose(...hocs)(componentWithMemo);
  } else {
    return componentWithMemo;
  }
};

const memoizeComponent = (areEqual: AreEqualOption, component: any, name: string, debugRerenders: boolean): any => {
  if (areEqual === "auto") {
    if (debugRerenders) {
      return React.memo(component, (oldProps, newProps) => {
        // eslint-disable-next-line no-console
        return debugShouldComponentUpdate(name, console.log, oldProps, {}, newProps, {});
      });
    } else {
      return React.memo(component);
    }
  } else if (typeof areEqual==='function') {
    return React.memo(component, areEqual);
  } else {
    return React.memo(component, (oldProps, newProps) => {
      const speciallyHandledKeys = Object.keys(areEqual);
      if (!shallowEqualExcept(oldProps, newProps, speciallyHandledKeys)) {
        if (debugRerenders) {
          // eslint-disable-next-line no-console
          debugShouldComponentUpdate(name, console.log, oldProps, {}, newProps, {});
        }
        return false;
      }
      for (let key of speciallyHandledKeys) {
        if (typeof areEqual[key]==="function") {
          if (!(areEqual[key] as ComparisonFn)(oldProps[key], newProps[key])) {
            if (debugRerenders) {
              // eslint-disable-next-line no-console
              console.log(`Updating ${name} because props.${key} changed`);
            }
            return false;
          }
        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
        } else switch(areEqual[key]) {
          case "ignore":
            break;
          case "default":
            if (oldProps[key] !== newProps[key]) {
              if (debugRerenders) {
                // eslint-disable-next-line no-console
                console.log(`Updating ${name} because props.${key} changed`);
              }
              return false;
            }
            break;
          case "shallow":
            if (!shallowEqual(oldProps[key], newProps[key])) {
              if (debugRerenders) {
                // eslint-disable-next-line no-console
                console.log(`Updating ${name} because props.${key} changed`);
              }
              return false;
            }
            break;
          case "deep":
            if (!_.isEqual(oldProps[key], newProps[key])) {
              if (debugRerenders) {
                // eslint-disable-next-line no-console
                console.log(`Updating ${name} because props.${key} changed`);
              }
              return false;
            }
            break;
        }
      }
      return true;
    });
  }
}

/**
 * Called once on app startup
 *
 * See debugComponentImports for intended use
 */
export const populateComponentsAppDebug = (): void => {
  if (debugComponentImports) {
    importAllComponents();
  }
};

// Returns an instance of the given component name of function
//
// @param {string|function} component  A component or registered component name
// @param {Object} [props]  Optional properties to pass to the component
export const instantiateComponent = (component: any, props: any) => {
  if (!component) {
    return null;
  } else if (typeof component === 'string') {
    const Component: any = Components[component as keyof ComponentTypes];
    return <Component {...props} />;
  } else if (
    typeof component === 'function' &&
    component.prototype &&
    component.prototype.isReactComponent
  ) {
    const Component = component;
    return <Component {...props} />;
  } else if (typeof component === 'function') {
    return component(props);
  } else {
    return component;
  }
};

/**
 * Given an optional set of override-components, return a Components object
 * which wraps the main Components table, preserving Components'
 * proxy/deferred-execution tricks.
 */
export const mergeWithComponents = (myComponents: Partial<ComponentTypes>|null|undefined): ComponentTypes => {
  if (!myComponents) return Components;
  
  if ((myComponents as any).__isProxy)
    return (myComponents as any);
  
  const mergedComponentsProxyHandler = {
    get: function(obj: any, prop: string) {
      if (prop === "__isProxy") {
        return true;
      } else if (prop in myComponents) {
        return (myComponents as any)[prop];
      } else if (prop in PreparedComponents) {
        return PreparedComponents[prop];
      } else {
        return prepareComponent(prop);
      }
    }
  }
  
  
  return new Proxy({}, mergedComponentsProxyHandler );
}

1	import compose from 'lodash/flowRight';	25,573✔
2	import React, { forwardRef } from 'react';	45✔
3	import { withStyles } from '@material-ui/core/styles';	45✔
4	import { shallowEqual, shallowEqualExcept, debugShouldComponentUpdate } from '../utils/componentUtils';	45✔
5	import { isClient } from '../executionEnvironment';	45✔
6	import * as _ from 'underscore';	45✔
7
8	type ComparisonFn = (prev: any, next: any) => boolean
9	type ComparePropsDict = { [propName: string]: "default"\|"shallow"\|"ignore"\|"deep"\|ComparisonFn }
10	type AreEqualOption = ComparisonFn\|ComparePropsDict\|"auto"
11
12	// Options passed to registerComponent
13	interface ComponentOptions {
14	// JSS styles for this component. These will generate class names, which will
15	// be passed as an extra prop named "classes".
16	styles?: any
17
18	// Whether to ignore the presence of colors that don't come from the theme in
19	// the component's stylesheet. Use for things that don't change color with
20	// dark mode.
21	allowNonThemeColors?: boolean,
22
23	// Default is 0. If classes with overlapping attributes from two different
24	// components' styles wind up applied to the same node, the one with higher
25	// priority wins.
26	stylePriority?: number,
27
28	// Array of higher-order components that this component should be wrapped
29	// with.
30	hocs?: Array<any>
31
32	// Determines what changes to props are considered relevant, for rerendering.
33	// Takes either "auto" (meaning a shallow comparison of all props), a function
34	// that takes before-and-after props, or an object where keys are names of
35	// props, values are how those props are handled, and props that are not
36	// mentioned are equality-compared. The options for handling a prop are a
37	// function or one of:
38	// * ignore: Don't rerender this component on changes to this prop
39	// * shallow: Shallow-compare this prop (this is one level deeper than the
40	// shallow comparison of all props)
41	// * deep: Perform a deep comparison of before and after values of this
42	// prop. (Don't use on prop types that are or contain React components)
43	areEqual?: AreEqualOption
44
45	// If set, output console log messages reporting when this component is
46	// rerendered, and which props changed to trigger it.
47	debugRerenders?: boolean,
48	}
49
50	interface ComponentsTableEntry {
51	name: string
52	rawComponent: any
53	hocs: Array<any>
54	options?: ComponentOptions,
55	}
56
57	const componentsProxyHandler = {	45✔
58	get: function(obj: {}, prop: string) {
59	if (prop === "__isProxy") {	20!
60	return true;	×
61	} else if (prop in PreparedComponents) {	20✔
62	return PreparedComponents[prop];	9✔
63	} else {
64	return prepareComponent(prop);	11✔
65	}
66	}
67	}
68
69	/**
70	* Acts like a mapping from component-name to component, based on
71	* registerComponents calls. Lazily loads those components when you dereference,
72	* using a proxy.
73	*/
74	export const Components: ComponentTypes = new Proxy({} as any, componentsProxyHandler);	45✔
75
76	const PreparedComponents: Record<string,any> = {};	45✔
77
78	// storage for infos about components
79	export const ComponentsTable: Record<string, ComponentsTableEntry> = {};	45✔
80
81	export const DeferredComponentsTable: Record<string,() => void> = {};	45✔
82
83	type EmailRenderContextType = {
84	isEmailRender: boolean
85	}
86
87	export const EmailRenderContext = React.createContext<EmailRenderContextType\|null>(null);	45✔
88
89	const classNameProxy = (prefix: string) => {	45✔
90	return new Proxy({}, {	1,487✔
91	get: function(obj: any, prop: any) {
92	// Check that the prop is really a string. This isn't an error that comes
93	// up normally, but apparently React devtools will try to query for non-
94	// string properties sometimes when using the component debugger.
95	if (typeof prop === "string")	×
96	return prefix+prop;	×
97	else
98	return prefix+'invalid';	×
99	}
100	});
101	}
102
103	const addClassnames = (componentName: string, styles: any) => {	45✔
104	const classesProxy = classNameProxy(componentName+'-');	1,487✔
105	return (WrappedComponent: any) => forwardRef((props, ref) => {	1,487✔
106	const emailRenderContext = React.useContext(EmailRenderContext);	×
107	if (emailRenderContext?.isEmailRender) {	×
108	const withStylesHoc = withStyles(styles, {name: componentName})	×
109	const StylesWrappedComponent = withStylesHoc(WrappedComponent)	×
110	return <StylesWrappedComponent {...props}/>	×
111	}
112	return <WrappedComponent ref={ref} {...props} classes={classesProxy}/>	×
113	})
114	}
115
116	export const useStyles = (styles: (theme: ThemeType) => JssStyles, componentName: keyof ComponentTypes) => {	45✔
117	return classNameProxy(componentName+'-');	×
118	};
119
120	// Register a component. Takes a name, a raw component, and ComponentOptions
121	// (see above). Components should be in their own file, imported with
122	// `importComponent`, and registered in that file; components that are
123	// registered this way can be accessed via the Components object and are lazy-
124	// loaded.
125	//
126	// Returns a dummy value--null, but coerced to a type that you can add to the
127	// ComponentTypes interface to type-check usages of the component in other
128	// files.
129	export function registerComponent<PropType>(name: string, rawComponent: React.ComponentType<PropType>,
130	options?: ComponentOptions): React.ComponentType<Omit<PropType,"classes">>
131	{
132	const { styles=null, hocs=[] } = options \|\| {};	2,033✔
133	if (styles) {	2,033✔
134	if (isClient && window?.missingMainStylesheet) {	1,487!
135	hocs.push(withStyles(styles, {name: name}));	×
136	} else {
137	hocs.push(addClassnames(name, styles));	1,487✔
138	}
139	}
140
141	rawComponent.displayName = name;	2,033✔
142
143	if (name in ComponentsTable && ComponentsTable[name].rawComponent !== rawComponent) {	2,033!
144	throw new Error(`Two components with the same name: ${name}`);	×
145	}
146
147	// store the component in the table
148	ComponentsTable[name] = {	2,033✔
149	name,
150	rawComponent,
151	hocs,
152	options,
153	};
154
155	// The Omit is a hacky way of ensuring that hocs props are omitted from the
156	// ones required to be passed in by parent components. It doesn't work for
157	// hocs that share prop names that overlap with actually passed-in props, like
158	// `location`.
159	return (null as any as React.ComponentType<Omit<PropType,"classes">>);	2,033✔
160	}
161
162	// If true, `importComponent` imports immediately (rather than deferring until
163	// first use) and checks that the file registered the components named, with a
164	// lot of log-spam.
165	const debugComponentImports = false;	45✔
166
167	export function importComponent(componentName: keyof ComponentTypes\|Array<keyof ComponentTypes>, importFn: () => void) {
168	if (Array.isArray(componentName)) {	21,261✔
169	for (let name of componentName) {	418✔
170	DeferredComponentsTable[name] = importFn;	1,273✔
171	}
172	} else {
173	DeferredComponentsTable[componentName] = importFn;	20,843✔
174	}
175	}
176
177	export function importAllComponents() {
178	for (let componentName of Object.keys(DeferredComponentsTable)) {	2✔
179	prepareComponent(componentName);	1,159✔
180	}
181	}
182
183	export function prepareComponent(componentName: string): any
184	{
185	if (componentName in PreparedComponents) {	2,202✔
186	return PreparedComponents[componentName];	9✔
187	} else if (componentName in ComponentsTable) {	2,193✔
188	PreparedComponents[componentName] = getComponent(componentName);	1,161✔
189	return PreparedComponents[componentName];	1,161✔
190	} else if (componentName in DeferredComponentsTable) {	1,032!
191	DeferredComponentsTable[componentName]();	1,032✔
192	if (!(componentName in ComponentsTable)) {	1,032!
193	throw new Error(`Import did not provide component ${componentName}`);	×
194	}
195	return prepareComponent(componentName);	1,032✔
196	} else {
197	// eslint-disable-next-line no-console
198	console.error(`Missing component: ${componentName}`);	×
199	return null;	×
200	}
201	}
202
203	// Get a component registered with registerComponent, applying HoCs and other
204	// wrappings.
205	const getComponent = (name: string): any => {	45✔
206	const componentMeta = ComponentsTable[name];	1,161✔
207	if (!componentMeta) {	1,161!
208	throw new Error(`Component ${name} not registered.`);	×
209	}
210
211	const componentWithMemo = componentMeta.options?.areEqual	1,161✔
212	? memoizeComponent(componentMeta.options.areEqual, componentMeta.rawComponent, name, !!componentMeta.options.debugRerenders)	1,161✔
213	: componentMeta.rawComponent;
214
215	if (componentMeta.hocs && componentMeta.hocs.length) {	1,161✔
216	const hocs = componentMeta.hocs.map(hoc => {	912✔
217	if (!Array.isArray(hoc)) {	987!
218	if (typeof hoc !== 'function') {	987!
219	throw new Error(`In registered component ${name}, an hoc is of type ${typeof hoc}`);	×
220	}
221	return hoc;	987✔
222	}
223	const [actualHoc, ...args] = hoc;	×
224	if (typeof actualHoc !== 'function') {	×
225	throw new Error(`In registered component ${name}, an hoc is of type ${typeof actualHoc}`);	×
226	}
227	return actualHoc(...args);	×
228	});
229	// @ts-ignore
230	return compose(...hocs)(componentWithMemo);	912✔
231	} else {
232	return componentWithMemo;	249✔
233	}
234	};
235
236	const memoizeComponent = (areEqual: AreEqualOption, component: any, name: string, debugRerenders: boolean): any => {	45✔
237	if (areEqual === "auto") {	21✔
238	if (debugRerenders) {	9!
239	return React.memo(component, (oldProps, newProps) => {	×
240	// eslint-disable-next-line no-console
241	return debugShouldComponentUpdate(name, console.log, oldProps, {}, newProps, {});	×
242	});
243	} else {
244	return React.memo(component);	9✔
245	}
246	} else if (typeof areEqual==='function') {	12!
247	return React.memo(component, areEqual);	×
248	} else {
249	return React.memo(component, (oldProps, newProps) => {	12✔
250	const speciallyHandledKeys = Object.keys(areEqual);	×
251	if (!shallowEqualExcept(oldProps, newProps, speciallyHandledKeys)) {	×
252	if (debugRerenders) {	×
253	// eslint-disable-next-line no-console
254	debugShouldComponentUpdate(name, console.log, oldProps, {}, newProps, {});	×
255	}
256	return false;	×
257	}
258	for (let key of speciallyHandledKeys) {	×
259	if (typeof areEqual[key]==="function") {	×
260	if (!(areEqual[key] as ComparisonFn)(oldProps[key], newProps[key])) {	×
261	if (debugRerenders) {	×
262	// eslint-disable-next-line no-console
263	console.log(`Updating ${name} because props.${key} changed`);	×
264	}
265	return false;	×
266	}
267	// eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
UNCOV 268	} else switch(areEqual[key]) {	×
269	case "ignore":
270	break;	×
271	case "default":
272	if (oldProps[key] !== newProps[key]) {	×
273	if (debugRerenders) {	×
274	// eslint-disable-next-line no-console
275	console.log(`Updating ${name} because props.${key} changed`);	×
276	}
277	return false;	×
278	}
279	break;	×
280	case "shallow":
281	if (!shallowEqual(oldProps[key], newProps[key])) {	×
282	if (debugRerenders) {	×
283	// eslint-disable-next-line no-console
284	console.log(`Updating ${name} because props.${key} changed`);	×
285	}
286	return false;	×
287	}
288	break;	×
289	case "deep":
290	if (!_.isEqual(oldProps[key], newProps[key])) {	×
291	if (debugRerenders) {	×
292	// eslint-disable-next-line no-console
293	console.log(`Updating ${name} because props.${key} changed`);	×
294	}
295	return false;	×
296	}
297	break;	×
298	}
299	}
300	return true;	×
301	});
302	}
303	}
304
305	/**
306	* Called once on app startup
307	*
308	* See debugComponentImports for intended use
309	*/
310	export const populateComponentsAppDebug = (): void => {	45✔
311	if (debugComponentImports) {	×
312	importAllComponents();	×
313	}
314	};
315
316	// Returns an instance of the given component name of function
317	//
318	// @param {string\|function} component A component or registered component name
319	// @param {Object} [props] Optional properties to pass to the component
320	export const instantiateComponent = (component: any, props: any) => {	45✔
321	if (!component) {	×
322	return null;	×
323	} else if (typeof component === 'string') {	×
324	const Component: any = Components[component as keyof ComponentTypes];	×
325	return <Component {...props} />;	×
326	} else if (	×
327	typeof component === 'function' &&	×
328	component.prototype &&
329	component.prototype.isReactComponent
330	) {
331	const Component = component;	×
332	return <Component {...props} />;	×
333	} else if (typeof component === 'function') {	×
334	return component(props);	×
335	} else {
336	return component;	×
337	}
338	};
339
340	/**
341	* Given an optional set of override-components, return a Components object
342	* which wraps the main Components table, preserving Components'
343	* proxy/deferred-execution tricks.
344	*/
345	export const mergeWithComponents = (myComponents: Partial<ComponentTypes>\|null\|undefined): ComponentTypes => {	45✔
346	if (!myComponents) return Components;	×
347
348	if ((myComponents as any).__isProxy)	×
349	return (myComponents as any);	×
350
351	const mergedComponentsProxyHandler = {	×
352	get: function(obj: any, prop: string) {
353	if (prop === "__isProxy") {	×
354	return true;	×
355	} else if (prop in myComponents) {	×
356	return (myComponents as any)[prop];	×
357	} else if (prop in PreparedComponents) {	×
358	return PreparedComponents[prop];	×
359	} else {
360	return prepareComponent(prop);	×
361	}
362	}
363	}
364
365
366	return new Proxy({}, mergedComponentsProxyHandler );	×
367	}

ForumMagnum / ForumMagnum / 10607476938

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous