swoop-common 2.0.7 → 2.0.8

package/dist/api/generated/swoop/core/request.js

@@ -243,7 +243,7 @@ const unwrapHydra = (json) => {
     // Get keys
     const keys = Object.keys(context);
     if (keys.length != 3) {
-        console.log("Unexpected number of keys within hydra context:", keys);
+        console.error("Unexpected number of keys within hydra context:", keys);
         return json;
     }
     // Get the key that is not hydra
@@ -251,7 +251,7 @@ const unwrapHydra = (json) => {
     // Main WILL exist, as there are 3 keys and filter max 2
     const data = json[main];
     if (!data) {
-        console.log("Hydra defined key did not exist within object:", Object.keys(json));
+        console.error("Hydra defined key did not exist within object:", Object.keys(json));
         return json;
     }
     return data;

package/dist/api/init.d.ts

@@ -1,6 +1,11 @@
 import * as Core from "./generated/core/index";
 import * as Itinerary from "./generated/itinerary/index";
 import * as Swoop from "./generated/swoop/index";
+export declare const InternalServices: {
+    SwoopService: Swoop.SwoopService;
+    CoreService: Core.CoreService;
+    ItineraryService: Itinerary.ItineraryService;
+};
 export declare const init: (opts: {
     itineraryServiceUrl: string;
     coreServiceUrl: string;

package/dist/api/init.js

@@ -2,6 +2,12 @@ import * as Core from "./generated/core/index";
 import * as Itinerary from "./generated/itinerary/index";
 import * as Swoop from "./generated/swoop/index";
 let initalised = false;
+// For internal use
+export const InternalServices = {
+    SwoopService: new Swoop.SwoopService(),
+    CoreService: new Core.CoreService(),
+    ItineraryService: new Itinerary.ItineraryService(),
+};
 export const init = (opts) => {
     // Keeps it consitent
     if (opts.coreServiceUrl.endsWith("/"))

package/dist/rendering/components/StyledFormView.d.ts

@@ -1,16 +1,13 @@
 import React from 'react';
 import { ComponentPool } from '../registry/types';
 import { MasterSchema, Stage } from '../schema/formSchemaTypes';
-interface Props {
+import { JsonSchema, Layout } from '@jsonforms/core';
+interface BaseProps {
     /**
      * This should only be used for the initial values, as this is not truly a controlled component.
-     * Frequent updates of this can cause significant perfomance dips.
+     * Frequent updates of this can cause significant performance dips.
      */
     initialData: any;
-    /**
-     * The master schema for this template
-     */
-    schema: MasterSchema;
     /**
      * This should not be fed back into the form.
      * Instead store it as a ref.
@@ -34,6 +31,36 @@ interface Props {
      * Should readonly fields be hidden
      */
     hideReadonlyFields?: boolean;
+    /**
+     * Hint at which component is being rendered, some forms may depend on component data
+     */
+    hintComponentId?: string;
+}
+interface SchemaProps extends BaseProps {
+    /**
+     * The master schema for this template
+     */
+    schema: MasterSchema;
+    /**
+     * These overrides are mutually exclusive with `schema`
+     */
+    overrideJsonSchema?: never;
+    overrideUiSchema?: never;
+}
+interface OverrideProps extends BaseProps {
+    /**
+     * The master schema for this template is mutually exclusive with overrides
+     */
+    schema?: never;
+    /**
+     * Override JSON schema
+     */
+    overrideJsonSchema: JsonSchema;
+    /**
+     * Override UI layout schema
+     */
+    overrideUiSchema: Layout;
 }
+type Props = SchemaProps | OverrideProps;
 export declare const StyledFormView: React.FC<Props>;
 export {};

package/dist/rendering/components/StyledFormView.js

@@ -5,9 +5,11 @@ import { getComponents } from '../registry/components';
 import { generateJsonSchema } from '../schema/generate/jsonSchemaGenerate';
 import { generateUiSchema } from '../schema/generate/uiSchemaGenerate';
 import { initialisedCheck } from '../../api/init';
-export const StyledFormView = ({ initialData, schema, onChange, stage, pool, readonly, hideReadonlyFields }) => {
+import ComponentContext from '../contexts/ComponentContext';
+export const StyledFormView = ({ initialData, schema, onChange, stage, pool, readonly, hideReadonlyFields, hintComponentId, overrideJsonSchema, overrideUiSchema }) => {
     useEffect(initialisedCheck, []);
-    const json = generateJsonSchema(schema, stage, hideReadonlyFields);
-    const ui = generateUiSchema(schema, stage, hideReadonlyFields);
-    return (React.createElement(JsonForms, { onChange: onChange, data: initialData, schema: json, uischema: ui, renderers: [...materialRenderers, ...getComponents(pool)], readonly: readonly, cells: materialCells }));
+    const json = overrideJsonSchema || generateJsonSchema(schema, stage, hideReadonlyFields);
+    const ui = overrideUiSchema || generateUiSchema(schema, stage, hideReadonlyFields);
+    return (React.createElement(ComponentContext, { componentId: hintComponentId, stage: stage },
+        React.createElement(JsonForms, { onChange: onChange, data: initialData, schema: json, uischema: ui, renderers: [...materialRenderers, ...getComponents(pool)], readonly: readonly, cells: materialCells })));
 };

package/dist/rendering/contexts/ComponentContext.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { DTOComponentRead } from '../../api';
+import { Stage } from '../schema/formSchemaTypes';
+interface Exported {
+    component?: DTOComponentRead;
+    stage: Stage;
+}
+export declare const CompContext: React.Context<Exported | null>;
+export declare const useCompContext: () => Exported;
+interface Props {
+    children: React.ReactNode;
+    componentId?: string;
+    stage: Stage;
+}
+declare const ComponentContext: React.FC<Props>;
+export default ComponentContext;

package/dist/rendering/contexts/ComponentContext.js

@@ -0,0 +1,30 @@
+import React, { createContext, useContext, useEffect, useState } from 'react';
+import { InternalServices } from '../../api/init';
+import { CircularProgress } from "@mui/material";
+export const CompContext = createContext(null);
+export const useCompContext = () => {
+    const cont = useContext(CompContext);
+    if (!cont)
+        throw new Error("useCompContext must be used from within a styled form");
+    return cont;
+};
+const ComponentContext = ({ children, componentId, stage }) => {
+    const [loading, setLoading] = useState(true);
+    const [component, setComponent] = useState();
+    useEffect(() => {
+        setLoading(true);
+        if (!componentId)
+            setLoading(false);
+        else {
+            setLoading(true);
+            InternalServices.CoreService.componentGet(componentId)
+                .then(setComponent)
+                .catch((e) => console.error(e.message))
+                .finally(() => setLoading(false));
+        }
+    }, [componentId]);
+    if (loading)
+        return React.createElement(CircularProgress, null);
+    return (React.createElement(CompContext.Provider, { value: { component, stage } }, children));
+};
+export default ComponentContext;

package/dist/rendering/hooks/errors.js

@@ -7,7 +7,6 @@ import React from "react";
  */
 export const useLocalErrors = (path) => {
     const { core } = useJsonForms();
-    console.log(core);
     // Filters out errors for the current scope
     const local = React.useMemo(() => {
         var _a;

package/dist/rendering/registry/fields.d.ts

@@ -1,10 +1,9 @@
-import { JsonSchema } from "@jsonforms/core";
 import { TemplateField } from "../schema/formBuilders/formBuilderJsonSchema";
 import { JsonSchemaWithXType } from "../types/jsonSchema";
 /**
  * If type is not a default json schema type, it is treated as x-type.
  * E.g. "number" will define the default number field, whereas "address" will define a custom field
  */
-export declare const registerType: (name: string, title: string, schema: JsonSchema, options: JsonSchemaWithXType, optionsRequired: boolean) => void;
+export declare const registerType: (name: string, title: string, schema: JsonSchemaWithXType, options: JsonSchemaWithXType, optionsRequired: boolean) => void;
 export declare const getAllTypes: () => Array<TemplateField>;
 export declare const getType: (xType: string) => TemplateField | undefined;

package/dist/rendering/renderers/Address.js

@@ -1,5 +1,5 @@
 'use client';
-import React, { useEffect, useMemo, useState } from 'react';
+import React, { useMemo, useState } from 'react';
 import { Paper, Typography, TextField, Grid, Divider } from '@mui/material';
 import { registerComponent } from '../registry/components';
 import { ComponentPool } from '../registry/types';
@@ -20,11 +20,6 @@ const FormAddress = ({ data, onChange, enabled, label, postcodePattern }) => {
         onChange('postcode', value);
     };
     const hasAddress = useMemo(() => !!(data.line1 || data.line2 || data.city || data.county || data.postcode), [data]);
-    useEffect(() => {
-        if (hasAddress) {
-            console.log('Address updated:', data);
-        }
-    }, [hasAddress, data]);
     return (React.createElement(Paper, { sx: { display: 'flex', flexDirection: 'column', gap: 2, p: 2, mb: 1 }, component: "form", noValidate: true, autoComplete: "off" },
         React.createElement(Typography, { variant: "h6" }, label),
         React.createElement(Grid, { container: true, spacing: 2 },

package/dist/rendering/renderers/Subset.js

@@ -1,47 +1,45 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import React, { useEffect, useState } from 'react';
-import { useLocalErrors } from '../hooks/errors';
+import { Resolve } from '@jsonforms/core';
+import React from 'react';
+import { Typography, TextField, Autocomplete } from '@mui/material';
 import { ComponentPool } from '../registry/types';
 import { registerComponent } from '../registry/components';
-import { CoreService } from '../../api/generated/core';
+import { useCompContext } from '../contexts/ComponentContext';
+import { Stage } from '../schema/formSchemaTypes';
+const FormRendererSubsetInstance = ({ data, handleChange, path, label, enabled }) => {
+    var _a;
+    const context = useCompContext();
+    const compData = (_a = context.component) === null || _a === void 0 ? void 0 : _a.componentFields.find(f => { var _a; return f.templateId === ((_a = context.component) === null || _a === void 0 ? void 0 : _a.templateId); });
+    if (!compData)
+        throw new Error("Subset has been rendered without a component hint");
+    const extracted = Resolve.data(compData.data, path);
+    if (!extracted)
+        throw new Error("Subset missing data");
+    const value = Array.isArray(data) ? data[0] || "" : (data !== null && data !== void 0 ? data : "");
+    const handleSelectChange = (_event, newValue) => {
+        handleChange(path, newValue ? [newValue] : []);
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Typography, null, label || "Select an option"),
+        React.createElement(Autocomplete, { options: extracted, value: value, onChange: handleSelectChange, disabled: !enabled, renderInput: (params) => (React.createElement(TextField, Object.assign({}, params, { variant: "outlined" }))), fullWidth: true })));
+};
 const FormRendererSubset = ({ data, handleChange, path, label, enabled, schema }) => {
-    // This needs to know the template and the component id... wip
-    const componentId = "";
-    const templateId = "";
-    const [component, setComponent] = useState();
-    const getError = useLocalErrors(path);
+    var _a;
     // @ts-ignore
-    const set = schema['x-set'] || [];
-    useEffect(() => {
-        const load = () => __awaiter(void 0, void 0, void 0, function* () {
-            try {
-                const comp = yield (new CoreService).componentGet(componentId);
-                setComponent(comp);
-            }
-            catch (err) {
-                console.error('Error loading component:', err);
-            }
-        });
-        load();
-    }, [set]);
-    const compData = component === null || component === void 0 ? void 0 : component.componentFields.find(f => f.templateId === templateId);
-    // Extract correct data obj, should be array of strings
-    const extracted = compData === null || compData === void 0 ? void 0 : compData.data; //.evalPath(path)
-    return React.createElement(React.Fragment, null, "WIP");
-    /*
-    return (
-        <Autocomplete
-            options={ }>
-
-        </Autocomplete>
-    )*/
+    const enumValues = ((_a = schema.items) === null || _a === void 0 ? void 0 : _a.enum) || [];
+    const value = (data && Array.isArray(data)) ? data : [];
+    const handleSelectChange = (_event, newValue) => {
+        handleChange(path, newValue);
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Typography, null, label || "Select options"),
+        React.createElement(Typography, null, "bettti"),
+        React.createElement(Autocomplete, { multiple: true, options: enumValues, value: value, onChange: handleSelectChange, disabled: !enabled, renderInput: (params) => React.createElement(TextField, Object.assign({}, params, { variant: "outlined" })), fullWidth: true })));
+};
+const Decider = (props) => {
+    const context = useCompContext();
+    if (context.stage === Stage.Comp)
+        return FormRendererSubset(props);
+    else
+        return FormRendererSubsetInstance(props);
 };
-registerComponent("TEMP DONT USE", FormRendererSubset, ComponentPool.FORM);
+registerComponent("stagedEnumComponentLevel", Decider, ComponentPool.FORM);

package/dist/rendering/schema/formBuilders/formBuilderJsonSchema.js

@@ -1,5 +1,6 @@
 import { CONSTRAINT_DEFINITIONS } from "../template/constraint";
 import { getAllTypes } from "../../registry/fields";
+import { Stage } from "../formSchemaTypes";
 const fields = getAllTypes();
 const fieldsToTypeDef = fields.map(f => ({
     "x-type": f.name,
@@ -154,7 +155,20 @@ export const FORM_BUILDER_JSON_SCHEMA = {
                     type: "string",
                     minLength: 1,
                     description: "Field name (used for both label and ID generation)",
-                }, description: { type: "string" }, required: { type: "boolean", default: false } }, fieldsToOptionsRecord),
+                }, description: { type: "string" }, required: { type: "boolean", default: false }, existsFrom: {
+                    "type": "string",
+                    "oneOf": Object.keys(Stage).filter((k) => isNaN(+k)).map(s => ({ title: s, const: Stage[s] + "" }))
+                }, editableIn: {
+                    type: "array",
+                    uniqueItems: true,
+                    items: {
+                        type: "string",
+                        oneOf: Object.keys(Stage).filter((k) => isNaN(+k)).map(s => ({
+                            title: s,
+                            const: Stage[s] + ""
+                        }))
+                    }
+                } }, fieldsToOptionsRecord),
             required: ["fieldType", "name"],
             dependencies: {
                 fieldType: {

package/dist/rendering/schema/formBuilders/formBuilderUiSchema.js

@@ -31,6 +31,8 @@ const fieldDetailLayout = {
         { type: "Control", scope: "#/properties/fieldType" },
         { type: "Control", scope: "#/properties/description" },
         { type: "Control", scope: "#/properties/required" },
+        { type: "Control", scope: "#/properties/existsFrom" },
+        { type: "Control", scope: "#/properties/editableIn" },
         ...generateFieldControlElements(["object", "array"]),
         {
             type: "Control",
@@ -192,17 +194,6 @@ export const FORM_BUILDER_UI_SCHEMA = {
                     options: { detail: fieldDetailLayout },
                 },
             ],
-        },
-        {
-            type: "Group",
-            label: "IB-Driven Fields",
-            elements: [
-                {
-                    type: "Control",
-                    scope: "#/properties/ibFormFields",
-                    options: { detail: fieldDetailLayout },
-                },
-            ],
-        },
+        }
     ],
 };

package/dist/rendering/schema/generate/formSchemaGenerate.js

@@ -9,7 +9,6 @@ export const generateFormSchema = (data) => {
         if (!validator(data)) {
             throw new Error("Data does not conform to a valid form schema");
         }
-        console.log(data);
         return data;
     }
     catch (e) {

package/dist/rendering/schema/generate/jsonSchemaGenerate.js

@@ -10,9 +10,9 @@ export const generateJsonSchema = (formSchema, stage, onlyEditableFields) => {
             required: [],
         };
         formSchema.forEach((s) => {
-            if (stage < s.existsFrom)
+            if (stage < +s.existsFrom)
                 return;
-            if (onlyEditableFields && !s.editableIn.includes(stage))
+            if (onlyEditableFields && !s.editableIn.map(Number).includes(stage))
                 return;
             const fieldSchema = defaultConverter(s, stage);
             built.properties[generateFieldId(s.name)] = fieldSchema;
@@ -51,7 +51,7 @@ const defaultConverter = (field, stage, omitTitle, isChild) => {
         if (child.required)
             requiredFields.push(fieldId);
     }
-    let enumOpts = field.fieldType === "enum" || field.fieldType === "stagedEnum"
+    let enumOpts = field.fieldType === "enum"
         ? (() => {
             var _a;
             let enumOptions = (((_a = field.enumOptions) === null || _a === void 0 ? void 0 : _a.enumValues) ||
@@ -61,10 +61,20 @@ const defaultConverter = (field, stage, omitTitle, isChild) => {
             return enumOptions;
         })()
         : undefined;
+    let stagedEnumOpts = field.fieldType === "stagedEnum"
+        ? (() => {
+            var _a;
+            let enumOptions = (((_a = field.stagedEnumOptions) === null || _a === void 0 ? void 0 : _a.enumValues) ||
+                []);
+            if (enumOptions.length === 0)
+                enumOptions.push("");
+            return enumOptions;
+        })()
+        : undefined;
     // Component (probably should change this)
     let templates = field.fieldType === "componentPicker"
         ? { "x-templateIds": (_e = field.componentOptions) === null || _e === void 0 ? void 0 : _e.templateIds }
         : {};
     let title = omitTitle ? undefined : field.name;
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (!isChild && !field.editableIn.includes(stage) && { readOnly: true })), { title, type: schema.schema.type, "x-type": schema.schema["x-type"] }), templates), (schema.schema.type === "object" && { properties })), { required: requiredFields }), (enumOpts && { enum: enumOpts })), (arrayItems && { items: arrayItems })), (field.fieldType === "object" && { properties }));
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (!isChild && !field.editableIn.map(Number).includes(stage) && { readOnly: true })), { title, type: schema.schema.type, "x-type": schema.schema["x-type"] }), templates), (schema.schema.type === "object" && { properties })), { required: requiredFields }), (enumOpts && { enum: enumOpts })), (stagedEnumOpts && { items: { enum: stagedEnumOpts, type: "string" } })), (arrayItems && { items: arrayItems })), (field.fieldType === "object" && { properties }));
 };

package/dist/rendering/schema/generate/uiSchemaGenerate.js

@@ -3,9 +3,9 @@ import { getAllTypes } from "../../registry/fields";
 export const generateUiSchema = (formSchema, stage, onlyEditableFields) => {
     const uiSchema = { type: "VerticalLayout", elements: [] };
     formSchema.forEach((field) => {
-        if (stage < field.existsFrom)
+        if (stage < +field.existsFrom)
             return;
-        if (onlyEditableFields && !field.editableIn.includes(stage))
+        if (onlyEditableFields && !field.editableIn.map(Number).includes(stage))
             return;
         uiSchema.elements.push(uiFieldSchemaFromFieldDefinition(field));
     });

package/dist/rendering/type_registration/register.js

@@ -40,20 +40,6 @@ registerType("enum", "Dropdown", { type: "string" }, {
         }
     }
 }, true);
-registerType("stagedEnum", "Staged Dropdown", {
-    type: "array",
-    items: { type: "string" },
-}, {
-    type: "object",
-    title: "Dropdown Options",
-    properties: {
-        enumValues: {
-            title: "Dropdown Values",
-            type: "array",
-            items: { type: "string" },
-        },
-    },
-}, true);
 registerType("array", "List", { type: "array" }, {
     type: "object",
     title: "List Options",
@@ -65,6 +51,7 @@ registerType("array", "List", { type: "array" }, {
     },
 }, true);
 registerType("stagedEnum", "Staged Dropdown", {
+    "x-type": "stagedEnumComponentLevel",
     type: "array",
     items: { type: "string" },
 }, {
@@ -75,7 +62,7 @@ registerType("stagedEnum", "Staged Dropdown", {
             title: "Dropdown Values",
             type: "array",
             items: { type: "string" },
-        },
+        }
     },
 }, true);
 registerType("object", "Group", { type: "object" }, {
@@ -145,23 +132,5 @@ registerType("address", "Address", {
     },
     required: ["line1", "city", "postcode"]
 }, {}, false);
-/*
-registerType(
-    "subset",
-    "Subset",
-    {
-        type: "object",
-        title: "Subset Options",
-        properties: {
-            minItems: { type: "integer", minimum: 0 },
-            maxItems: { type: "integer", minimum: 1 },
-            uniqueItems: { type: "boolean", default: false },
-            itemDefinition: { $ref: "#/$defs/arrayItemDefinition" },
-        },
-    },
-    {
-    },
-    false
-);*/
 registerType("image", "Image", { type: "string" }, {}, false);
 registerType("multiline", "Multiline", { type: "string" }, {}, false);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "swoop-common",
-    "version": "2.0.7",
+    "version": "2.0.8",
     "main": "dist/api/index.js",
     "types": "dist/api/index.d.ts",
     "exports": {