8738958178

Committed 18 Apr 2024 01:37PM UTC coverage: 32.066% (+0.02%) from 32.042%

Build # 8738958178

Build Type

push

github

Committed by

Will-Howard

Commit Message

Merge branch 'master' of github.com:ForumMagnum/ForumMagnum into wh-frontload-bundle-imports-2024-04

Run Details

4685 of 37976 branches covered (12.34%)

Branch coverage included in aggregate %.

104 of 241 new or added lines in 25 files covered. (43.15%)

5 existing lines in 5 files now uncovered.

27170 of 61366 relevant lines covered (44.28%)

182.04 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;
          }
        } 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';	22,556✔
2	import React, { forwardRef } from 'react';	44✔
3	import { withStyles } from '@material-ui/core/styles';	44✔
4	import { shallowEqual, shallowEqualExcept, debugShouldComponentUpdate } from '../utils/componentUtils';	44✔
5	import { isClient } from '../executionEnvironment';	44✔
6	import * as _ from 'underscore';	44✔
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 = {	44✔
58	get: function(obj: {}, prop: string) {
59	if (prop === "__isProxy") {	12!
60	return true;	×
61	} else if (prop in PreparedComponents) {	12✔
62	return PreparedComponents[prop];	3✔
63	} else {
64	return prepareComponent(prop);	9✔
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);	44✔
75
76	const PreparedComponents: Record<string,any> = {};	44✔
77
78	// storage for infos about components
79	export const ComponentsTable: Record<string, ComponentsTableEntry> = {};	44✔
80
81	export const DeferredComponentsTable: Record<string,() => void> = {};	44✔
82
83	type EmailRenderContextType = {
84	isEmailRender: boolean
85	}
86
87	export const EmailRenderContext = React.createContext<EmailRenderContextType\|null>(null);	44✔
88
89	const classNameProxy = (prefix: string) => {	44✔
90	return new Proxy({}, {	1,375✔
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")	×
NEW 96	return prefix+prop;	×
97	else
NEW 98	return prefix+'invalid';	×
99	}
100	});
101	}
102
103	const addClassnames = (componentName: string, styles: any) => {	44✔
104	const classesProxy = classNameProxy(componentName+'-');	1,375✔
105	return (WrappedComponent: any) => forwardRef((props, ref) => {	1,375✔
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) => {	44✔
NEW 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 \|\| {};	1,892✔
133	if (styles) {	1,892✔
134	if (isClient && window?.missingMainStylesheet) {	1,375!
135	hocs.push(withStyles(styles, {name: name}));	×
136	} else {
137	hocs.push(addClassnames(name, styles));	1,375✔
138	}
139	}
140
141	rawComponent.displayName = name;	1,892✔
142
143	if (name in ComponentsTable && ComponentsTable[name].rawComponent !== rawComponent) {	1,892!
144	throw new Error(`Two components with the same name: ${name}`);	×
145	}
146
147	// store the component in the table
148	ComponentsTable[name] = {	1,892✔
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">>);	1,892✔
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;	44✔
166
167	export function importComponent(componentName: keyof ComponentTypes\|Array<keyof ComponentTypes>, importFn: () => void) {
168	if (Array.isArray(componentName)) {	18,558✔
169	for (let name of componentName) {	342✔
170	DeferredComponentsTable[name] = importFn;	1,062✔
171	}
172	} else {
173	DeferredComponentsTable[componentName] = importFn;	18,216✔
174	}
175	}
176
177	export function importAllComponents() {
178	for (let componentName of Object.keys(DeferredComponentsTable)) {	2✔
179	prepareComponent(componentName);	1,066✔
180	}
181	}
182
183	export function prepareComponent(componentName: string): any
184	{
185	if (componentName in PreparedComponents) {	2,020✔
186	return PreparedComponents[componentName];	9✔
187	} else if (componentName in ComponentsTable) {	2,011✔
188	PreparedComponents[componentName] = getComponent(componentName);	1,066✔
189	return PreparedComponents[componentName];	1,066✔
190	} else if (componentName in DeferredComponentsTable) {	945!
191	DeferredComponentsTable[componentName]();	945✔
192	if (!(componentName in ComponentsTable)) {	945!
193	throw new Error(`Import did not provide component ${componentName}`);	×
194	}
195	return prepareComponent(componentName);	945✔
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 => {	44✔
206	const componentMeta = ComponentsTable[name];	1,066✔
207	if (!componentMeta) {	1,066!
208	throw new Error(`Component ${name} not registered.`);	×
209	}
210
211	const componentWithMemo = componentMeta.options?.areEqual	1,066✔
212	? memoizeComponent(componentMeta.options.areEqual, componentMeta.rawComponent, name, !!componentMeta.options.debugRerenders)	1,066✔
213	: componentMeta.rawComponent;
214
215	if (componentMeta.hocs && componentMeta.hocs.length) {	1,066✔
216	const hocs = componentMeta.hocs.map(hoc => {	831✔
217	if (!Array.isArray(hoc)) {	904!
218	if (typeof hoc !== 'function') {	904!
219	throw new Error(`In registered component ${name}, an hoc is of type ${typeof hoc}`);	×
220	}
221	return hoc;	904✔
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);	831✔
231	} else {
232	return componentWithMemo;	235✔
233	}
234	};
235
236	const memoizeComponent = (areEqual: AreEqualOption, component: any, name: string, debugRerenders: boolean): any => {	44✔
237	if (areEqual === "auto") {	17✔
238	if (debugRerenders) {	7!
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);	7✔
245	}
246	} else if (typeof areEqual==='function') {	10!
247	return React.memo(component, areEqual);	×
248	} else {
249	return React.memo(component, (oldProps, newProps) => {	10✔
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	} else switch(areEqual[key]) {	×
268	case "ignore":
269	break;	×
270	case "default":
271	if (oldProps[key] !== newProps[key]) {	×
272	if (debugRerenders) {	×
273	// eslint-disable-next-line no-console
274	console.log(`Updating ${name} because props.${key} changed`);	×
275	}
276	return false;	×
277	}
278	break;	×
279	case "shallow":
280	if (!shallowEqual(oldProps[key], newProps[key])) {	×
281	if (debugRerenders) {	×
282	// eslint-disable-next-line no-console
283	console.log(`Updating ${name} because props.${key} changed`);	×
284	}
285	return false;	×
286	}
287	break;	×
288	case "deep":
289	if (!_.isEqual(oldProps[key], newProps[key])) {	×
290	if (debugRerenders) {	×
291	// eslint-disable-next-line no-console
292	console.log(`Updating ${name} because props.${key} changed`);	×
293	}
294	return false;	×
295	}
296	break;	×
297	}
298	}
299	return true;	×
300	});
301	}
302	}
303
304	/**
305	* Called once on app startup
306	*
307	* See debugComponentImports for intended use
308	*/
309	export const populateComponentsAppDebug = (): void => {	44✔
310	if (debugComponentImports) {	×
311	importAllComponents();	×
312	}
313	};
314
315	// Returns an instance of the given component name of function
316	//
317	// @param {string\|function} component A component or registered component name
318	// @param {Object} [props] Optional properties to pass to the component
319	export const instantiateComponent = (component: any, props: any) => {	44✔
320	if (!component) {	×
321	return null;	×
322	} else if (typeof component === 'string') {	×
323	const Component: any = Components[component as keyof ComponentTypes];	×
324	return <Component {...props} />;	×
325	} else if (	×
326	typeof component === 'function' &&	×
327	component.prototype &&
328	component.prototype.isReactComponent
329	) {
330	const Component = component;	×
331	return <Component {...props} />;	×
332	} else if (typeof component === 'function') {	×
333	return component(props);	×
334	} else {
335	return component;	×
336	}
337	};
338
339	/**
340	* Given an optional set of override-components, return a Components object
341	* which wraps the main Components table, preserving Components'
342	* proxy/deferred-execution tricks.
343	*/
344	export const mergeWithComponents = (myComponents: Partial<ComponentTypes>\|null\|undefined): ComponentTypes => {	44✔
345	if (!myComponents) return Components;	×
346
347	if ((myComponents as any).__isProxy)	×
348	return (myComponents as any);	×
349
350	const mergedComponentsProxyHandler = {	×
351	get: function(obj: any, prop: string) {
352	if (prop === "__isProxy") {	×
353	return true;	×
354	} else if (prop in myComponents) {	×
355	return (myComponents as any)[prop];	×
356	} else if (prop in PreparedComponents) {	×
357	return PreparedComponents[prop];	×
358	} else {
359	return prepareComponent(prop);	×
360	}
361	}
362	}
363
364
365	return new Proxy({}, mergedComponentsProxyHandler );	×
366	}

ForumMagnum / ForumMagnum / 8738958178

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