@j2inn/resolvable-ui-elements 2.0.0 → 2.1.0

package/dist_es/resolvableElements/interfacesGeneration/generateInterfaces.js

@@ -1,40 +1,40 @@
-/*
- * Copyright (c) 2022, J2 Innovations. All Rights Reserved
- */
-import { HDict } from 'haystack-core';
-import { Client } from 'haystack-nclient';
-import { isResolvableValueElementMeta } from '../elements/ResolvableValueElement';
-import { isChildUnresolvedSection, ResolvableSectionElement, } from '../elements/section/ResolvableSectionElement';
-import { Resolver } from '../Resolver';
-const ROOT_NAME = 'UiElementRoot';
-const ELEMENT_INTERFACE_NAME = 'UiElementData';
-export const generateInterfaces = (section) => {
-    return new SectionInterfacesGenerator(section).generate();
-};
-/**
- * Class for generating typescript interfaces from a section data.
- */
-export class SectionInterfacesGenerator {
-    constructor(section) {
-        this.sectionData = section;
-    }
-    sectionData;
-    output = '';
-    #out = (str, indentation = 0) => {
-        this.output += this.#indent(indentation) + str + '\n';
-    };
-    #indent(indentation = 0) {
-        return '\t'.repeat(indentation);
-    }
-    generate = () => {
-        this.#generateImports();
-        const section = makeResolvableSectionElementMock(this.sectionData);
-        this.#generateSectionDefinition(section);
-        const result = this.output;
-        this.output = '';
-        return result;
-    };
-    #generateImports() {
+/*
+ * Copyright (c) 2022, J2 Innovations. All Rights Reserved
+ */
+import { HDict } from 'haystack-core';
+import { Client } from 'haystack-nclient';
+import { isResolvableValueElementMeta } from '../elements/ResolvableValueElement';
+import { isChildUnresolvedSection, ResolvableSectionElement, } from '../elements/section/ResolvableSectionElement';
+import { Resolver } from '../Resolver';
+const ROOT_NAME = 'UiElementRoot';
+const ELEMENT_INTERFACE_NAME = 'UiElementData';
+export const generateInterfaces = (section) => {
+    return new SectionInterfacesGenerator(section).generate();
+};
+/**
+ * Class for generating typescript interfaces from a section data.
+ */
+export class SectionInterfacesGenerator {
+    constructor(section) {
+        this.sectionData = section;
+    }
+    sectionData;
+    output = '';
+    #out = (str, indentation = 0) => {
+        this.output += this.#indent(indentation) + str + '\n';
+    };
+    #indent(indentation = 0) {
+        return '\t'.repeat(indentation);
+    }
+    generate = () => {
+        this.#generateImports();
+        const section = makeResolvableSectionElementMock(this.sectionData);
+        this.#generateSectionDefinition(section);
+        const result = this.output;
+        this.output = '';
+        return result;
+    };
+    #generateImports() {
         this.#out(`/* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 
@@ -53,95 +53,95 @@ export const UI_ELEMENTS = json as UiElementRoot
 //////////////////////////////////////////////////////////////////////////
 // Interfaces
 //////////////////////////////////////////////////////////////////////////
-`);
-    }
-    #generateSectionDefinition(section, indentation = 0) {
-        this.generateInterface(section, indentation);
-        if (hasChildrenSections(section)) {
-            this.generateNamespace(section, indentation);
-        }
-    }
-    generateInterface(section, indentation) {
-        const name = section.name ?? ROOT_NAME;
-        this.#out(`export interface ${capitalize(name)} extends UiElementData {`, indentation);
-        const parameters = section.getParameterList();
-        if (parameters.length > 0) {
-            this.#generateParametersProperty(parameters, indentation + 1);
-        }
-        this.#generateResolvedProperty(section, indentation + 1);
-        section.children.forEach((child) => this.#out(isChildUnresolvedSection(child)
-            ? `${child[0]}: ${capitalize(name)}.${capitalize(child[0] ?? '')}`
-            : `${child.name}: ${ELEMENT_INTERFACE_NAME}`, indentation + 1));
-        this.#out(`}`, indentation);
-    }
-    #generateParametersProperty(parameters, indentation) {
-        this.#out(`_parameters?: {`, indentation);
-        parameters.forEach((param) => this.#out(`${param}: HCore.HVal`, indentation + 1));
-        this.#out(`}`, indentation);
-    }
-    #generateResolvedProperty(section, indentation) {
-        const name = section.name ?? ROOT_NAME;
-        if (section.children.length > 0) {
-            this.#out('_resolved?: {', indentation);
-            section.children.forEach((child) => this.#out(isChildUnresolvedSection(child)
-                ? `${child[0]}?: ${capitalize(name)}.${capitalize(child[0] ?? '')}`
-                : `${child.name}?: ${getResolvedType(child)}`, indentation + 1));
-            this.#out('}', indentation);
-        }
-        else {
-            this.#out(`_resolved?: Record<string, unknown>`, indentation);
-        }
-    }
-    generateNamespace(section, indentation) {
-        const name = section.name ?? ROOT_NAME;
-        this.#out(`export namespace ${capitalize(name)} {`, indentation);
-        section.children
-            .filter((child) => isChildUnresolvedSection(child))
-            .forEach((child) => {
-            if (isChildUnresolvedSection(child)) {
-                const section = makeResolvableSectionElementMock(child[1], child[0]);
-                this.#generateSectionDefinition(section, indentation + 1);
-            }
-        });
-        this.#out(`}`, indentation);
-    }
-}
-export function makeResolvableSectionElementMock(sectionData, name) {
-    return new ResolvableSectionElement({
-        name,
-        element: sectionData,
-        onUpdate: () => {
-            return;
-        },
-        resolver: new Resolver({
-            client: makeMockedClient(),
-            user: HDict.make({ userRole: 'su' }),
-        }),
-    });
-}
-function makeMockedClient() {
-    return new Client({
-        base: new URL('http://localhost:8080'),
-        fetch: () => new Promise(() => {
-            return new Response();
-        }),
-    });
-}
-function capitalize(str) {
-    return str.charAt(0)?.toUpperCase() + str.substring(1);
-}
-function getResolvedType(child) {
-    if (child._meta && isResolvableValueElementMeta(child._meta)) {
-        return child._meta.resolvedType.startsWith('H')
-            ? 'HCore.' + child._meta.resolvedType
-            : child._meta.resolvedType;
-    }
-    else {
-        return 'unknown';
-    }
-}
-function hasChildrenSections(section) {
-    return (section.children.filter((child) => isChildUnresolvedSection(child))
-        .length > 0);
-}
+`);
+    }
+    #generateSectionDefinition(section, indentation = 0) {
+        this.generateInterface(section, indentation);
+        if (hasChildrenSections(section)) {
+            this.generateNamespace(section, indentation);
+        }
+    }
+    generateInterface(section, indentation) {
+        const name = section.name ?? ROOT_NAME;
+        this.#out(`export interface ${capitalize(name)} extends UiElementData {`, indentation);
+        const parameters = section.getParameterList();
+        if (parameters.length > 0) {
+            this.#generateParametersProperty(parameters, indentation + 1);
+        }
+        this.#generateResolvedProperty(section, indentation + 1);
+        section.children.forEach((child) => this.#out(isChildUnresolvedSection(child)
+            ? `${child[0]}: ${capitalize(name)}.${capitalize(child[0] ?? '')}`
+            : `${child.name}: ${ELEMENT_INTERFACE_NAME}`, indentation + 1));
+        this.#out(`}`, indentation);
+    }
+    #generateParametersProperty(parameters, indentation) {
+        this.#out(`_parameters?: {`, indentation);
+        parameters.forEach((param) => this.#out(`${param}: HCore.HVal`, indentation + 1));
+        this.#out(`}`, indentation);
+    }
+    #generateResolvedProperty(section, indentation) {
+        const name = section.name ?? ROOT_NAME;
+        if (section.children.length > 0) {
+            this.#out('_resolved?: {', indentation);
+            section.children.forEach((child) => this.#out(isChildUnresolvedSection(child)
+                ? `${child[0]}?: ${capitalize(name)}.${capitalize(child[0] ?? '')}`
+                : `${child.name}?: ${getResolvedType(child)}`, indentation + 1));
+            this.#out('}', indentation);
+        }
+        else {
+            this.#out(`_resolved?: Record<string, unknown>`, indentation);
+        }
+    }
+    generateNamespace(section, indentation) {
+        const name = section.name ?? ROOT_NAME;
+        this.#out(`export namespace ${capitalize(name)} {`, indentation);
+        section.children
+            .filter((child) => isChildUnresolvedSection(child))
+            .forEach((child) => {
+            if (isChildUnresolvedSection(child)) {
+                const section = makeResolvableSectionElementMock(child[1], child[0]);
+                this.#generateSectionDefinition(section, indentation + 1);
+            }
+        });
+        this.#out(`}`, indentation);
+    }
+}
+export function makeResolvableSectionElementMock(sectionData, name) {
+    return new ResolvableSectionElement({
+        name,
+        element: sectionData,
+        onUpdate: () => {
+            return;
+        },
+        resolver: new Resolver({
+            client: makeMockedClient(),
+            user: HDict.make({ userRole: 'su' }),
+        }),
+    });
+}
+function makeMockedClient() {
+    return new Client({
+        base: new URL('http://localhost:8080'),
+        fetch: () => new Promise(() => {
+            return new Response();
+        }),
+    });
+}
+function capitalize(str) {
+    return str.charAt(0)?.toUpperCase() + str.substring(1);
+}
+function getResolvedType(child) {
+    if (child._meta && isResolvableValueElementMeta(child._meta)) {
+        return child._meta.resolvedType.startsWith('H')
+            ? 'HCore.' + child._meta.resolvedType
+            : child._meta.resolvedType;
+    }
+    else {
+        return 'unknown';
+    }
+}
+function hasChildrenSections(section) {
+    return (section.children.filter((child) => isChildUnresolvedSection(child))
+        .length > 0);
+}
 //# sourceMappingURL=generateInterfaces.js.map

package/dist_es/resolvableElements/interfacesGeneration/generateTypescriptInterfacesFile.d.ts

@@ -1,4 +1,4 @@
-/**
- * Generate typescript interfaces file from json ui-elements data
- */
-export default function generateTypescriptInterfacesFile(inputPath?: string, outputPath?: string): Promise<void>;
+/**
+ * Generate typescript interfaces file from json ui-elements data
+ */
+export default function generateTypescriptInterfacesFile(inputPath?: string, outputPath?: string): Promise<void>;

package/dist_es/resolvableElements/interfacesGeneration/generateTypescriptInterfacesFile.js

@@ -1,16 +1,16 @@
-/*
- * Copyright (c) 2022, J2 Innovations. All Rights Reserved
- */
-import * as fs from 'fs';
-import { generateInterfaces } from './generateInterfaces';
-/**
- * Generate typescript interfaces file from json ui-elements data
- */
-export default async function generateTypescriptInterfacesFile(inputPath = '../elements.json', outputPath = '../elements.ts') {
-    console.log(`Generating interfaces from ${inputPath} \n...`);
-    const json = fs.readFileSync(inputPath, { encoding: 'utf-8' });
-    const result = generateInterfaces(JSON.parse(json));
-    fs.writeFileSync(outputPath, result);
-    console.log(`File successfully generated at: ${outputPath}`);
-}
+/*
+ * Copyright (c) 2022, J2 Innovations. All Rights Reserved
+ */
+import * as fs from 'fs';
+import { generateInterfaces } from './generateInterfaces';
+/**
+ * Generate typescript interfaces file from json ui-elements data
+ */
+export default async function generateTypescriptInterfacesFile(inputPath = '../elements.json', outputPath = '../elements.ts') {
+    console.log(`Generating interfaces from ${inputPath} \n...`);
+    const json = fs.readFileSync(inputPath, { encoding: 'utf-8' });
+    const result = generateInterfaces(JSON.parse(json));
+    fs.writeFileSync(outputPath, result);
+    console.log(`File successfully generated at: ${outputPath}`);
+}
 //# sourceMappingURL=generateTypescriptInterfacesFile.js.map

package/dist_es/resolvableElements/react/SectionChecker.d.ts

@@ -1,24 +1,24 @@
-import React from 'react';
-import { UiElementData } from 'resolvableElements/elements/UiElement';
-/**
- * An utility type that allows a component to accept props with or without a 'section' property.
- */
-export type OptionalSection<P> = P | (Omit<P, 'section'> & {
-    section?: undefined;
-});
-/**
- * Higher-Order Component that takes a section based component as an argument and returns a new component
- * that checks if the 'section' prop is defined before rendering the SectionComponent.
- * If the 'section' prop is undefined, it returns an empty element.
- *
- * @template P - Props of the original SectionComponent
- * @param {React.FC<P>} SectionComponent - The original component that will be wrapped
- * @returns {React.FC<P | (Omit<P, 'section'> & { section?: undefined })>} - The wrapped component
- * @example
- * const CheckedComponent = SectionChecker(({section, ...props}) => {
- *   return <div>{section.title}</div>
- * })
- */
-export declare const SectionChecker: <P extends {
-    section: UiElementData;
-}>(SectionComponent: React.FC<P>) => (props: OptionalSection<P>) => JSX.Element;
+import React from 'react';
+import { UiElementData } from 'resolvableElements/elements/UiElement';
+/**
+ * An utility type that allows a component to accept props with or without a 'section' property.
+ */
+export type OptionalSection<P> = P | (Omit<P, 'section'> & {
+    section?: undefined;
+});
+/**
+ * Higher-Order Component that takes a section based component as an argument and returns a new component
+ * that checks if the 'section' prop is defined before rendering the SectionComponent.
+ * If the 'section' prop is undefined, it returns an empty element.
+ *
+ * @template P - Props of the original SectionComponent
+ * @param {React.FC<P>} SectionComponent - The original component that will be wrapped
+ * @returns {React.FC<P | (Omit<P, 'section'> & { section?: undefined })>} - The wrapped component
+ * @example
+ * const CheckedComponent = SectionChecker(({section, ...props}) => {
+ *   return <div>{section.title}</div>
+ * })
+ */
+export declare const SectionChecker: <P extends {
+    section: UiElementData;
+}>(SectionComponent: React.FC<P>) => (props: OptionalSection<P>) => JSX.Element;

package/dist_es/resolvableElements/react/SectionChecker.jsx

@@ -1,21 +1,21 @@
-import React from 'react';
-/**
- * Higher-Order Component that takes a section based component as an argument and returns a new component
- * that checks if the 'section' prop is defined before rendering the SectionComponent.
- * If the 'section' prop is undefined, it returns an empty element.
- *
- * @template P - Props of the original SectionComponent
- * @param {React.FC<P>} SectionComponent - The original component that will be wrapped
- * @returns {React.FC<P | (Omit<P, 'section'> & { section?: undefined })>} - The wrapped component
- * @example
- * const CheckedComponent = SectionChecker(({section, ...props}) => {
- *   return <div>{section.title}</div>
- * })
- */
-export const SectionChecker = (SectionComponent) => {
-    const CheckedSectionComponent = (props) => {
-        return !props.section ? <></> : <SectionComponent {...props}/>;
-    };
-    return CheckedSectionComponent;
-};
+import React from 'react';
+/**
+ * Higher-Order Component that takes a section based component as an argument and returns a new component
+ * that checks if the 'section' prop is defined before rendering the SectionComponent.
+ * If the 'section' prop is undefined, it returns an empty element.
+ *
+ * @template P - Props of the original SectionComponent
+ * @param {React.FC<P>} SectionComponent - The original component that will be wrapped
+ * @returns {React.FC<P | (Omit<P, 'section'> & { section?: undefined })>} - The wrapped component
+ * @example
+ * const CheckedComponent = SectionChecker(({section, ...props}) => {
+ *   return <div>{section.title}</div>
+ * })
+ */
+export const SectionChecker = (SectionComponent) => {
+    const CheckedSectionComponent = (props) => {
+        return !props.section ? <></> : <SectionComponent {...props}/>;
+    };
+    return CheckedSectionComponent;
+};
 //# sourceMappingURL=SectionChecker.jsx.map

package/dist_es/resolvableElements/react/useResolveSection.d.ts

@@ -1,21 +1,21 @@
-import { UiElementData } from '../elements/UiElement';
-import { ResolvableSectionElement } from '../elements/section/ResolvableSectionElement';
-import { ParametersOfSection, ResolvedSection } from '../elements/section/SectionElementMeta';
-/**
- * Resolves a section UI element.
- * IMPORTANT: This hook requires a resolver react context defined. @See `ResolverProvider`.
- * @param sectionData section data object
- * @param parameters parameters for the resolution
- * @returns the resolved result of the section that will be updated and force rendering when a subvalue changes.
- */
-export declare function useResolveSection<T extends UiElementData>(sectionData: T, parameters?: ParametersOfSection<T>): UseResolveSectionResult<T>;
-export type UseResolveSectionResult<T extends UiElementData> = [
-    ResolvedSection<T>,
-    UseResolveSectionExtra<T>
-];
-export interface UseResolveSectionExtra<T extends UiElementData> {
-    refresh: () => void;
-    element?: ResolvableSectionElement<T>;
-    loads: number;
-    isLoading: boolean;
-}
+import { UiElementData } from '../elements/UiElement';
+import { ResolvableSectionElement } from '../elements/section/ResolvableSectionElement';
+import { ParametersOfSection, ResolvedSection } from '../elements/section/SectionElementMeta';
+/**
+ * Resolves a section UI element.
+ * IMPORTANT: This hook requires a resolver react context defined. @See `ResolverProvider`.
+ * @param sectionData section data object
+ * @param parameters parameters for the resolution
+ * @returns the resolved result of the section that will be updated and force rendering when a subvalue changes.
+ */
+export declare function useResolveSection<T extends UiElementData>(sectionData: T, parameters?: ParametersOfSection<T>): UseResolveSectionResult<T>;
+export type UseResolveSectionResult<T extends UiElementData> = [
+    ResolvedSection<T>,
+    UseResolveSectionExtra<T>
+];
+export interface UseResolveSectionExtra<T extends UiElementData> {
+    refresh: () => void;
+    element?: ResolvableSectionElement<T>;
+    loads: number;
+    isLoading: boolean;
+}

package/dist_es/resolvableElements/react/useResolveSection.js

@@ -1,62 +1,62 @@
-/*
- * Copyright (c) 2022, J2 Innovations. All Rights Reserved
- */
-import { useEffect, useReducer, useRef, useState } from 'react';
-import { makeParametersDict } from '../elements/function/FunctionElement';
-import { ResolvableSectionElement } from '../elements/section/ResolvableSectionElement';
-import { areParametersValid } from '../elements/section/resolveSection';
-import { useResolverContext } from './useResolverContext';
-/**
- * Resolves a section UI element.
- * IMPORTANT: This hook requires a resolver react context defined. @See `ResolverProvider`.
- * @param sectionData section data object
- * @param parameters parameters for the resolution
- * @returns the resolved result of the section that will be updated and force rendering when a subvalue changes.
- */
-export function useResolveSection(sectionData, parameters) {
-    const [, update] = useReducer((count) => count + 1, 0);
-    const resolver = useResolverContext();
-    const [refreshes, refresh] = useReducer((count) => count + 1, 0);
-    const [loads, setLoads] = useState(0);
-    const [isLoading, setLoading] = useState(false);
-    const ref = useRef();
-    if (!ref.current) {
-        ref.current = new ResolvableSectionElement({
-            element: sectionData,
-            resolver,
-            onUpdate: update,
-        });
-    }
-    const parametersDict = makeParametersDict(parameters);
-    useEffect(() => {
-        if (areParametersValid(parameters)) {
-            ref.current = new ResolvableSectionElement({
-                element: sectionData,
-                resolver,
-                onUpdate: update,
-            });
-            setLoading(true);
-            const promise = ref.current
-                .initialize(parametersDict)
-                .then(() => setLoads(loads + 1))
-                .finally(() => setLoading(false));
-            return () => {
-                const sectionElement = ref.current;
-                promise.finally(() => {
-                    sectionElement?.close();
-                });
-            };
-        }
-        return;
-    }, [sectionData, resolver, refreshes, parametersDict.toAxon()]);
-    return [
-        (ref.current.value ?? {}),
-        {
-            refresh: refresh,
-            element: ref.current,
-            loads,
-            isLoading,
-        },
-    ];
-}
+/*
+ * Copyright (c) 2022, J2 Innovations. All Rights Reserved
+ */
+import { useEffect, useReducer, useRef, useState } from 'react';
+import { makeParametersDict } from '../elements/function/FunctionElement';
+import { ResolvableSectionElement } from '../elements/section/ResolvableSectionElement';
+import { areParametersValid } from '../elements/section/resolveSection';
+import { useResolverContext } from './useResolverContext';
+/**
+ * Resolves a section UI element.
+ * IMPORTANT: This hook requires a resolver react context defined. @See `ResolverProvider`.
+ * @param sectionData section data object
+ * @param parameters parameters for the resolution
+ * @returns the resolved result of the section that will be updated and force rendering when a subvalue changes.
+ */
+export function useResolveSection(sectionData, parameters) {
+    const [, update] = useReducer((count) => count + 1, 0);
+    const resolver = useResolverContext();
+    const [refreshes, refresh] = useReducer((count) => count + 1, 0);
+    const [loads, setLoads] = useState(0);
+    const [isLoading, setLoading] = useState(false);
+    const ref = useRef();
+    if (!ref.current) {
+        ref.current = new ResolvableSectionElement({
+            element: sectionData,
+            resolver,
+            onUpdate: update,
+        });
+    }
+    const parametersDict = makeParametersDict(parameters);
+    useEffect(() => {
+        if (areParametersValid(parameters)) {
+            ref.current = new ResolvableSectionElement({
+                element: sectionData,
+                resolver,
+                onUpdate: update,
+            });
+            setLoading(true);
+            const promise = ref.current
+                .initialize(parametersDict)
+                .then(() => setLoads(loads + 1))
+                .finally(() => setLoading(false));
+            return () => {
+                const sectionElement = ref.current;
+                promise.finally(() => {
+                    sectionElement?.close();
+                });
+            };
+        }
+        return;
+    }, [sectionData, resolver, refreshes, parametersDict.toAxon()]);
+    return [
+        (ref.current.value ?? {}),
+        {
+            refresh: refresh,
+            element: ref.current,
+            loads,
+            isLoading,
+        },
+    ];
+}
 //# sourceMappingURL=useResolveSection.js.map

package/dist_es/resolvableElements/react/useResolverContext.d.ts

@@ -1,9 +1,9 @@
-import React, { PropsWithChildren } from 'react';
-import { Resolver } from '../Resolver';
-export declare function useResolverContext(): Resolver;
-interface ResolverProviderProps extends PropsWithChildren {
-    userRoleTagName?: string;
-    evalFuncName?: string;
-}
-export declare const ResolverProvider: React.FC<ResolverProviderProps>;
-export {};
+import React, { PropsWithChildren } from 'react';
+import { Resolver } from '../Resolver';
+export declare function useResolverContext(): Resolver;
+interface ResolverProviderProps extends PropsWithChildren {
+    userRoleTagName?: string;
+    evalFuncName?: string;
+}
+export declare const ResolverProvider: React.FC<ResolverProviderProps>;
+export {};