2558092373

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #686 from repetere/esbuild

Run Details

659 of 833 branches covered (79.11%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

780 of 842 relevant lines covered (92.64%)

16.73 hits per line

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

85.47

/src/index.ts

// import React, { createElement, } from 'react';
import React, { ReactNode } from "react";
import ReactDOM from "react-dom";
import { createRoot } from 'react-dom/client';
import ReactDOMServer from "react-dom/server";
import * as defs from "./types/jsonx/index";

import * as jsonxComponents from "./components";
import * as jsonxProps from "./props";
import * as jsonxChildren from "./children";
import * as jsonxUtils from "./utils";
import numeral from "numeral";
import * as luxon from "luxon";

import { ReactElementLike } from "prop-types";
import { JSONReactElement, Context } from "./types/jsonx/index";
const createElement = React.createElement;
const {
  componentMap,
  getComponentFromMap,
  getBoundedComponents,
  DynamicComponent,
  FormComponent,
  ReactHookForm,
  getReactLibrariesAndComponents,
} = jsonxComponents;
const { getComputedProps } = jsonxProps;
const { getJSONXChildren } = jsonxChildren;
const { displayComponent, validSimpleJSONXSyntax, simpleJSONXSyntax } = jsonxUtils;
export let renderIndex = 0;

/**
 * Use JSONX without any configuration to render JSONX JSON to HTML and insert JSONX into querySelector using ReactDOM.render
 * @example
 * // Uses react to create <!DOCTYPE html><body><div id="myApp"><div class="jsonx-generated"><p style="color:red;">hello world</p></div></div></body>
 * jsonx.jsonxRender({ jsonx: { component: 'div', props:{className:'jsonx-generated',children:[{ component:'p',props:{style:{color:'red'}}, children:'hello world' }]}}, querySelector:'#myApp', });
 * @param {object} config - options used to inject html via ReactDOM.render
 * @param {object} config.jsonx - any valid JSONX JSON object
 * @param {object} config.resources - any additional resource used for asynchronous properties
 * @param {string} config.querySelector - selector for document.querySelector
 * @property {object} this - options for getReactElementFromJSONX
 */
export function jsonxRender(
  this: defs.Context,
  config: defs.RenderConfig = { jsonx: { component: "" }, querySelector: "" }
): void {
  const { jsonx, resources, querySelector, DOM, portal } = config;
  const RenderDOM: HTMLElement | null =
    DOM || document.querySelector(querySelector);
  const JSONXReactElement: any = getReactElementFromJSONX.call(
    this || {},
    jsonx,
    resources
  );
  if (!JSONXReactElement) throw ReferenceError("Invalid React Element");
  else if (!RenderDOM) throw ReferenceError("Invalid Render DOM Element");
  if(portal) ReactDOM.createPortal(JSONXReactElement, RenderDOM);
  else {
    const root = createRoot(RenderDOM);
    root.render(JSONXReactElement);
  }
}

/**
 * Use ReactDOMServer.renderToString to render html from JSONX
 * @example
 * // Uses react to create <div class="jsonx-generated"><p style="color:red;">hello world</p></div>
 * jsonx.outputHTML({ jsonx: { component: 'div', props:{className:'jsonx-generated',children:[{ component:'p',props:{style:{color:'red'}}, children:'hello world' }]}}, });
 * @param {object} config - options used to inject html via ReactDOM.render
 * @param {object} config.jsonx - any valid JSONX JSON object
 * @param {object} config.resources - any additional resource used for asynchronous properties
 * @property {object} this - options for getReactElementFromJSONX
 * @returns {string} React genereated html via JSONX JSON
 */
export function outputHTML(
  this: defs.OutputHTMLContext,
  config: defs.OutputHTMLConfig = { jsonx: { component: "" } }
): string {
  const { jsonx, resources, type, props, children } = config;

  return this && this.useJSON
    ? ReactDOMServer.renderToString(
        getReactElementFromJSON.call(this || {}, { type:(type||jsonx.type||jsonx.component||'Fragment' as string), props:props||jsonx.props, children:children||jsonx.children })
      )
    : ReactDOMServer.renderToString(
        getReactElementFromJSONX.call(
          this || {},
          jsonx,
          resources
        ) as ReactElementLike
      );
}

/**
 * Use React.createElement and JSONX JSON to create React elements
 * @example
 * // Uses react to create the equivalent JSX <myComponent style={{color:blue}}>hello world</myComponent>
 * jsonx.getReactElementFromJSONX({component:'myCompnent',props:{style:{color:'blue'}},children:'hello world'})
 * @param {object} jsonx - any valid JSONX JSON object
 * @param {object} resources - any additional resource used for asynchronous properties
 * @property {object} this - options for getReactElementFromJSONX
 * @property {Object} [this.componentLibraries] - react components to render with JSONX
 * @property {boolean} [this.debug=false] - use debug messages
 * @property {boolean} [this.returnJSON=false] - return json object of {type,props,children} instead of react element
 * @property {boolean} [this.disableRenderIndexKey=false] - disables auto assign a key prop
 * @property {function} [this.logError=console.error] - error logging function
 * @property {string[]} [this.boundedComponents=[]] - list of components that require a bound this context (usefult for redux router)
 * @returns {function} React element via React.createElement
 */
export function getReactElementFromJSONX(
  this: defs.Context,
  jsonx?: defs.jsonx | defs.simpleJsonx,
  resources = {}
): ReactElementLike | JSONReactElement | null |string|undefined{
  // eslint-disable-next-line
  const {
    customComponents,
    debug = false,
    returnJSON = false,
    logError = console.error,
    boundedComponents = [],
    disableRenderIndexKey = true
  } = this || {};
  let {
    componentLibraries = {},
  } = this ||{};
  componentLibraries.ReactHookForm = ReactHookForm
  if (!jsonx) return null;
  if (jsonx.type) jsonx.component = jsonx.type;
  if (!jsonx.component && validSimpleJSONXSyntax(jsonx)) {
    jsonx = simpleJSONXSyntax(jsonx);
  }
  if (!jsonx || !jsonx.component)
    return createElement(
      "span",
      {},
      debug ? "Error: Missing Component Object" : ""
    );
  try {
    let components = Object.assign(
      { DynamicComponent: DynamicComponent.bind(this) },
      { FormComponent: FormComponent.bind(this) },
      componentMap,
      this?.reactComponents
    );

    let reactComponents = boundedComponents.length
      ? getBoundedComponents.call(this, {
          boundedComponents,
          reactComponents: components
        })
      : components;
    if(customComponents && Array.isArray(customComponents) && customComponents.length){
      const cxt = {...this,componentLibraries,reactComponents:components}
      const {
        customComponentLibraries,
        customReactComponents
      } = getReactLibrariesAndComponents.call(cxt,customComponents);
      componentLibraries = {...componentLibraries, ...customComponentLibraries};
      reactComponents = {...reactComponents, ...customReactComponents};
    }
    if(disableRenderIndexKey===false) renderIndex++;
    const element = getComponentFromMap.call(this, {
      jsonx,
      reactComponents,
      componentLibraries,
      debug,
      logError
    });
    const props = getComputedProps.call(this, {
      jsonx,
      resources,
      renderIndex,
      componentLibraries,
      debug,
      logError,
      disableRenderIndexKey
    });
    const displayElement = jsonx.comparisonprops
      ? displayComponent.call(this, {
          jsonx,
          props,
          renderIndex,
          componentLibraries,
          debug
        })
      : true;
    if (displayElement) {
      const children = getJSONXChildren.call(this, {
        jsonx,
        props,
        resources,
        renderIndex
      }) as ReactNode[];
      //@ts -ignore
      if (returnJSON) return { type: element as string, props, children };
      else if (jsonx.test) return JSON.stringify({ element, props, children }, null, 2);
      //TODO: Fix
      else return createElement(element, props, children);
    } else {
      return null;
    }
  } catch (e) {
    if (debug) {
      logError({ jsonx, resources }, "getReactElementFromJSONX this", this);
      logError(e, (e as Error).stack ? (e as Error).stack : "no stack");
      return (e as Error).toString()
    }
    throw e;
  }
}

export const getRenderedJSON = getReactElementFromJSONX;
export const getReactElement = getReactElementFromJSONX;

/** converts a json object {type,props,children} into a react element
 * @example
 * jsonx.getReactElementFromJSON({type:'div',props:{title:'some title attribute'},children:'inner html text'})
 * @param {Object|String} options.type - 'div' or react component
 * @param {Object} options.props - props for react element
 * @param {String|[Object]} options.children - children elements
 * @returns {function} React element via React.createElement
 */
export function getReactElementFromJSON({
  type,
  props,
  children
}: JSONReactElement): ReactElementLike {
  return createElement(
    type,
    props,
    children && Array.isArray(children)
      ? children.map(getReactElementFromJSON)
      : children
  );
}

/** converts a jsonx json object into a react function component
 * @example
 * jsonx.compile({jsonx:{component:'div',props:{title:'some title attribute'},children:'inner html text'}}) //=>React Function Component
 * @param {Object} jsonx - valid JSONX JSON
 * @param {Object} resources - props for react element
 * @returns {function} React element via React.createElement
 */
export function compile(this: Context, jsonx: defs.jsonx, resources = {}) {
  const context = Object.assign({}, this, { returnJSON: true });
  const json = getReactElementFromJSONX.call(
    context,
    jsonx,
    resources
  ) as defs.JSONReactElement;
  const func = function compiledJSONX(props: any) {
    json.props = Object.assign({}, json.props, props);
    return getReactElementFromJSON(json);
  };
  Object.defineProperty(func, "name", { value: this.name });
  return func;
}

/**
 * converts JSONX JSON IR to JSX
 * @example
 * jsonx.jsonToJSX({ type: 'div', props: { key: 5, title: 'test' }, children: 'hello' }) // => '<div key={5} title="test">hello</div>'
 * @param {Object} json - {type,props,children}
 * @returns {String} jsx string
 */
export function outputJSX(this: Context, jsonx: defs.jsonx, resources = {}) {
  const context = Object.assign({}, this, { returnJSON: true });
  const json = getReactElementFromJSONX.call(
    context,
    jsonx,
    resources
  ) as defs.JSONReactElement;
  return jsonToJSX(json);
}

/**
 * Compiles JSONX into JSON IR format for react create element
 * @example
 * jsonx.outputJSON({ component: 'div', props: { title: 'test', }, children: 'hello', }); //=> { type: 'div',
 props: { key: 5, title: 'test' },
 children: 'hello' }
 * @property {object} this - options for getReactElementFromJSONX
 * @param {object} jsonx - any valid JSONX JSON object
 * @param {object} resources - any additional resource used for asynchronous properties
 * @returns {Object} json - {type,props,children}
 */
export function outputJSON(
  jsonx: defs.jsonx,
  resources = {}
): JSONReactElement {
  //@ts-ignore
  const context = Object.assign({}, this, { returnJSON: true });
  return getReactElementFromJSONX.call(
    context,
    jsonx,
    resources
  ) as JSONReactElement;
}
export const jsonxHTMLString = outputHTML;

/**
 * converts JSONX JSON IR to JSX
 * @example
 * jsonx.jsonToJSX({ type: 'div', props: { key: 5, title: 'test' }, children: 'hello' }) // => '<div key={5} title="test">hello</div>'
 * @param {Object} json - {type,props,children}
 * @returns {String} jsx string
 */
export function jsonToJSX(json: JSONReactElement): string {
  const propsString = json.props
    ? Object.keys(json.props)
        .filter(prop => prop.includes("__eval_") === false)
        .reduce((propString, prop) => {
          propString += ` ${prop.toString()}=${
            typeof json.props[prop] === "string"
              ? `"${json.props[prop].toString()}"`
              : `{${(
                  json.props[`__eval_${prop}`] || json.props[prop]
                ).toString()}}`
          }`;
          return propString;
        }, "")
    : "";
  return Array.isArray(json.children)
    ? `<${json.type} ${propsString}>
  ${json.children.map(jsonToJSX).join('\r\n')}
</${json.type}>`
    : `<${json.type}${propsString}>${json.children}</${json.type}>`;
}
/**
 * Exposes react module used in JSONX
 * @returns {Object} React
 */
export function __getReact() {
  return React;
}

/**
 * Exposes react dom module used in JSONX
 * @returns {Object} ReactDOM
 */
export function __getReactDOM() {
  return ReactDOM;
}

export const _jsonxChildren = jsonxChildren;
export const _jsonxComponents = jsonxComponents;
export const _jsonxProps = jsonxProps;
export const _jsonxUtils = jsonxUtils;
export const _jsonxHelpers = { numeral, luxon };
export { __express, __express as renderFile } from "./express";

export default getReactElementFromJSONX;

1	// import React, { createElement, } from 'react';
2	import React, { ReactNode } from "react";	5✔
3	import ReactDOM from "react-dom";	5✔
4	import { createRoot } from 'react-dom/client';	5✔
5	import ReactDOMServer from "react-dom/server";	5✔
6	import * as defs from "./types/jsonx/index";
7
8	import * as jsonxComponents from "./components";	5✔
9	import * as jsonxProps from "./props";	5✔
10	import * as jsonxChildren from "./children";	5✔
11	import * as jsonxUtils from "./utils";	5✔
12	import numeral from "numeral";	5✔
13	import * as luxon from "luxon";	5✔
14
15	import { ReactElementLike } from "prop-types";
16	import { JSONReactElement, Context } from "./types/jsonx/index";
17	const createElement = React.createElement;	5✔
18	const {
19	componentMap,
20	getComponentFromMap,
21	getBoundedComponents,
22	DynamicComponent,
23	FormComponent,
24	ReactHookForm,
25	getReactLibrariesAndComponents,
26	} = jsonxComponents;	5✔
27	const { getComputedProps } = jsonxProps;	5✔
28	const { getJSONXChildren } = jsonxChildren;	5✔
29	const { displayComponent, validSimpleJSONXSyntax, simpleJSONXSyntax } = jsonxUtils;	5✔
30	export let renderIndex = 0;	5✔
31
32	/**
33	* Use JSONX without any configuration to render JSONX JSON to HTML and insert JSONX into querySelector using ReactDOM.render
34	* @example
35	* // Uses react to create <!DOCTYPE html><body><div id="myApp"><div class="jsonx-generated"><p style="color:red;">hello world</p></div></div></body>
36	* jsonx.jsonxRender({ jsonx: { component: 'div', props:{className:'jsonx-generated',children:[{ component:'p',props:{style:{color:'red'}}, children:'hello world' }]}}, querySelector:'#myApp', });
37	* @param {object} config - options used to inject html via ReactDOM.render
38	* @param {object} config.jsonx - any valid JSONX JSON object
39	* @param {object} config.resources - any additional resource used for asynchronous properties
40	* @param {string} config.querySelector - selector for document.querySelector
41	* @property {object} this - options for getReactElementFromJSONX
42	*/
43	export function jsonxRender(	5✔
44	this: defs.Context,
45	config: defs.RenderConfig = { jsonx: { component: "" }, querySelector: "" }	×
46	): void {
47	const { jsonx, resources, querySelector, DOM, portal } = config;	1✔
48	const RenderDOM: HTMLElement \| null =
49	DOM \|\| document.querySelector(querySelector);	1!
50	const JSONXReactElement: any = getReactElementFromJSONX.call(	1✔
51	this \|\| {},	1!
52	jsonx,
53	resources
54	);
55	if (!JSONXReactElement) throw ReferenceError("Invalid React Element");	1!
56	else if (!RenderDOM) throw ReferenceError("Invalid Render DOM Element");	1!
57	if(portal) ReactDOM.createPortal(JSONXReactElement, RenderDOM);	1!
58	else {
59	const root = createRoot(RenderDOM);	1✔
60	root.render(JSONXReactElement);	1✔
61	}
62	}
63
64	/**
65	* Use ReactDOMServer.renderToString to render html from JSONX
66	* @example
67	* // Uses react to create <div class="jsonx-generated"><p style="color:red;">hello world</p></div>
68	* jsonx.outputHTML({ jsonx: { component: 'div', props:{className:'jsonx-generated',children:[{ component:'p',props:{style:{color:'red'}}, children:'hello world' }]}}, });
69	* @param {object} config - options used to inject html via ReactDOM.render
70	* @param {object} config.jsonx - any valid JSONX JSON object
71	* @param {object} config.resources - any additional resource used for asynchronous properties
72	* @property {object} this - options for getReactElementFromJSONX
73	* @returns {string} React genereated html via JSONX JSON
74	*/
75	export function outputHTML(	5✔
76	this: defs.OutputHTMLContext,
77	config: defs.OutputHTMLConfig = { jsonx: { component: "" } }	×
78	): string {
79	const { jsonx, resources, type, props, children } = config;	11✔
80
81	return this && this.useJSON	11!
82	? ReactDOMServer.renderToString(
83	getReactElementFromJSON.call(this \|\| {}, { type:(type\|\|jsonx.type\|\|jsonx.component\|\|'Fragment' as string), props:props\|\|jsonx.props, children:children\|\|jsonx.children })	×
84	)
85	: ReactDOMServer.renderToString(
86	getReactElementFromJSONX.call(
87	this \|\| {},	11!
88	jsonx,
89	resources
90	) as ReactElementLike
91	);
92	}
93
94	/**
95	* Use React.createElement and JSONX JSON to create React elements
96	* @example
97	* // Uses react to create the equivalent JSX <myComponent style={{color:blue}}>hello world</myComponent>
98	* jsonx.getReactElementFromJSONX({component:'myCompnent',props:{style:{color:'blue'}},children:'hello world'})
99	* @param {object} jsonx - any valid JSONX JSON object
100	* @param {object} resources - any additional resource used for asynchronous properties
101	* @property {object} this - options for getReactElementFromJSONX
102	* @property {Object} [this.componentLibraries] - react components to render with JSONX
103	* @property {boolean} [this.debug=false] - use debug messages
104	* @property {boolean} [this.returnJSON=false] - return json object of {type,props,children} instead of react element
105	* @property {boolean} [this.disableRenderIndexKey=false] - disables auto assign a key prop
106	* @property {function} [this.logError=console.error] - error logging function
107	* @property {string[]} [this.boundedComponents=[]] - list of components that require a bound this context (usefult for redux router)
108	* @returns {function} React element via React.createElement
109	*/
110	export function getReactElementFromJSONX(	5✔
111	this: defs.Context,
112	jsonx?: defs.jsonx \| defs.simpleJsonx,
113	resources = {}	30✔
114	): ReactElementLike \| JSONReactElement \| null \|string\|undefined{
115	// eslint-disable-next-line
116	const {
117	customComponents,
118	debug = false,	81✔
119	returnJSON = false,	83✔
120	logError = console.error,	96✔
121	boundedComponents = [],	98✔
122	disableRenderIndexKey = true	44✔
123	} = this \|\| {};	102!
124	let {
125	componentLibraries = {},	94✔
126	} = this \|\|{};	102!
127	componentLibraries.ReactHookForm = ReactHookForm	102✔
128	if (!jsonx) return null;	102✔
129	if (jsonx.type) jsonx.component = jsonx.type;	101✔
130	if (!jsonx.component && validSimpleJSONXSyntax(jsonx)) {	101✔
131	jsonx = simpleJSONXSyntax(jsonx);	13✔
132	}
133	if (!jsonx \|\| !jsonx.component)	101✔
134	return createElement(	3✔
135	"span",
136	{},
137	debug ? "Error: Missing Component Object" : ""	3✔
138	);
139	try {	98✔
140	let components = Object.assign(	98✔
141	{ DynamicComponent: DynamicComponent.bind(this) },
142	{ FormComponent: FormComponent.bind(this) },
143	componentMap,
144	this?.reactComponents
145	);
146
147	let reactComponents = boundedComponents.length	98✔
148	? getBoundedComponents.call(this, {
149	boundedComponents,
150	reactComponents: components
151	})
152	: components;
153	if(customComponents && Array.isArray(customComponents) && customComponents.length){	98✔
154	const cxt = {...this,componentLibraries,reactComponents:components}	12✔
155	const {
156	customComponentLibraries,
157	customReactComponents
158	} = getReactLibrariesAndComponents.call(cxt,customComponents);	12✔
159	componentLibraries = {...componentLibraries, ...customComponentLibraries};	12✔
160	reactComponents = {...reactComponents, ...customReactComponents};	12✔
161	}
162	if(disableRenderIndexKey===false) renderIndex++;	98✔
163	const element = getComponentFromMap.call(this, {	98✔
164	jsonx,
165	reactComponents,
166	componentLibraries,
167	debug,
168	logError
169	});
170	const props = getComputedProps.call(this, {	93✔
171	jsonx,
172	resources,
173	renderIndex,
174	componentLibraries,
175	debug,
176	logError,
177	disableRenderIndexKey
178	});
179	const displayElement = jsonx.comparisonprops	93!
180	? displayComponent.call(this, {
181	jsonx,
182	props,
183	renderIndex,
184	componentLibraries,
185	debug
186	})
187	: true;
188	if (displayElement) {	93!
189	const children = getJSONXChildren.call(this, {	93✔
190	jsonx,
191	props,
192	resources,
193	renderIndex
194	}) as ReactNode[];
195	//@ts -ignore
196	if (returnJSON) return { type: element as string, props, children };	93✔
197	else if (jsonx.test) return JSON.stringify({ element, props, children }, null, 2);	75✔
198	//TODO: Fix
199	else return createElement(element, props, children);	74✔
200	} else {
UNCOV 201	return null;	×
202	}
203	} catch (e) {
204	if (debug) {	5✔
205	logError({ jsonx, resources }, "getReactElementFromJSONX this", this);	3✔
206	logError(e, (e as Error).stack ? (e as Error).stack : "no stack");	3!
207	return (e as Error).toString()	3✔
208	}
209	throw e;	2✔
210	}
211	}
212
213	export const getRenderedJSON = getReactElementFromJSONX;	5✔
214	export const getReactElement = getReactElementFromJSONX;	5✔
215
216	/** converts a json object {type,props,children} into a react element
217	* @example
218	* jsonx.getReactElementFromJSON({type:'div',props:{title:'some title attribute'},children:'inner html text'})
219	* @param {Object\|String} options.type - 'div' or react component
220	* @param {Object} options.props - props for react element
221	* @param {String\|[Object]} options.children - children elements
222	* @returns {function} React element via React.createElement
223	*/
224	export function getReactElementFromJSON({	5✔
225	type,
226	props,
227	children
228	}: JSONReactElement): ReactElementLike {
229	return createElement(	6✔
230	type,
231	props,
232	children && Array.isArray(children)	18✔
233	? children.map(getReactElementFromJSON)
234	: children
235	);
236	}
237
238	/** converts a jsonx json object into a react function component
239	* @example
240	* jsonx.compile({jsonx:{component:'div',props:{title:'some title attribute'},children:'inner html text'}}) //=>React Function Component
241	* @param {Object} jsonx - valid JSONX JSON
242	* @param {Object} resources - props for react element
243	* @returns {function} React element via React.createElement
244	*/
245	export function compile(this: Context, jsonx: defs.jsonx, resources = {}) {	5✔
246	const context = Object.assign({}, this, { returnJSON: true });	1✔
247	const json = getReactElementFromJSONX.call(	1✔
248	context,
249	jsonx,
250	resources
251	) as defs.JSONReactElement;
252	const func = function compiledJSONX(props: any) {	1✔
253	json.props = Object.assign({}, json.props, props);	1✔
254	return getReactElementFromJSON(json);	1✔
255	};
256	Object.defineProperty(func, "name", { value: this.name });	1✔
257	return func;	1✔
258	}
259
260	/**
261	* converts JSONX JSON IR to JSX
262	* @example
263	* jsonx.jsonToJSX({ type: 'div', props: { key: 5, title: 'test' }, children: 'hello' }) // => '<div key={5} title="test">hello</div>'
264	* @param {Object} json - {type,props,children}
265	* @returns {String} jsx string
266	*/
267	export function outputJSX(this: Context, jsonx: defs.jsonx, resources = {}) {	5✔
268	const context = Object.assign({}, this, { returnJSON: true });	1✔
269	const json = getReactElementFromJSONX.call(	1✔
270	context,
271	jsonx,
272	resources
273	) as defs.JSONReactElement;
274	return jsonToJSX(json);	1✔
275	}
276
277	/**
278	* Compiles JSONX into JSON IR format for react create element
279	* @example
280	* jsonx.outputJSON({ component: 'div', props: { title: 'test', }, children: 'hello', }); //=> { type: 'div',
281	props: { key: 5, title: 'test' },
282	children: 'hello' }
283	* @property {object} this - options for getReactElementFromJSONX
284	* @param {object} jsonx - any valid JSONX JSON object
285	* @param {object} resources - any additional resource used for asynchronous properties
286	* @returns {Object} json - {type,props,children}
287	*/
288	export function outputJSON(	5✔
289	jsonx: defs.jsonx,
290	resources = {}	1✔
291	): JSONReactElement {
292	//@ts-ignore
293	const context = Object.assign({}, this, { returnJSON: true });	1✔
294	return getReactElementFromJSONX.call(	1✔
295	context,
296	jsonx,
297	resources
298	) as JSONReactElement;
299	}
300	export const jsonxHTMLString = outputHTML;	5✔
301
302	/**
303	* converts JSONX JSON IR to JSX
304	* @example
305	* jsonx.jsonToJSX({ type: 'div', props: { key: 5, title: 'test' }, children: 'hello' }) // => '<div key={5} title="test">hello</div>'
306	* @param {Object} json - {type,props,children}
307	* @returns {String} jsx string
308	*/
309	export function jsonToJSX(json: JSONReactElement): string {	5✔
310	const propsString = json.props	5!
311	? Object.keys(json.props)
312	.filter(prop => prop.includes("__eval_") === false)	6✔
313	.reduce((propString, prop) => {
314	propString += ` ${prop.toString()}=${	5✔
315	typeof json.props[prop] === "string"	5✔
316	? `"${json.props[prop].toString()}"`
317	: `{${(
318	json.props[`__eval_${prop}`] \|\| json.props[prop]	3✔
319	).toString()}}`
320	}`;
321	return propString;	5✔
322	}, "")
323	: "";
324	return Array.isArray(json.children)	5✔
325	? `<${json.type} ${propsString}>
326	${json.children.map(jsonToJSX).join('\r\n')}
327	</${json.type}>`
328	: `<${json.type}${propsString}>${json.children}</${json.type}>`;
329	}
330	/**
331	* Exposes react module used in JSONX
332	* @returns {Object} React
333	*/
334	export function __getReact() {	5✔
335	return React;	1✔
336	}
337
338	/**
339	* Exposes react dom module used in JSONX
340	* @returns {Object} ReactDOM
341	*/
342	export function __getReactDOM() {	5✔
343	return ReactDOM;	1✔
344	}
345
346	export const _jsonxChildren = jsonxChildren;	5✔
347	export const _jsonxComponents = jsonxComponents;	5✔
348	export const _jsonxProps = jsonxProps;	5✔
349	export const _jsonxUtils = jsonxUtils;	5✔
350	export const _jsonxHelpers = { numeral, luxon };	5✔
351	export { __express, __express as renderFile } from "./express";	20✔
352
353	export default getReactElementFromJSONX;	5✔

repetere / jsonx / 2558092373

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