swoop-common 1.0.43 → 2.0.1

package/dist/rendering/schema/formSchemaTypes.d.ts

@@ -0,0 +1,15 @@
+export type MasterSchema = Array<MasterFieldDefinition>;
+export declare enum Stage {
+    Comp = 0,
+    Inst = 1,
+    User = 2
+}
+export interface MasterFieldDefinition {
+    fieldType: string;
+    name: string;
+    description?: string;
+    required?: boolean;
+    [key: `${string}Options`]: Record<string, any> | undefined;
+    editableIn: Array<Stage>;
+    existsFrom: Stage;
+}

package/dist/rendering/schema/formSchemaTypes.js

@@ -0,0 +1,6 @@
+export var Stage;
+(function (Stage) {
+    Stage[Stage["Comp"] = 0] = "Comp";
+    Stage[Stage["Inst"] = 1] = "Inst";
+    Stage[Stage["User"] = 2] = "User";
+})(Stage || (Stage = {}));

package/dist/rendering/schema/generate/formSchemaGenerate.d.ts

@@ -0,0 +1,3 @@
+export declare const generateFormSchema: (data: any) => {
+    [x: string]: {};
+} | undefined;

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

@@ -0,0 +1,19 @@
+import Ajv from "ajv";
+import { FORM_BUILDER_JSON_SCHEMA } from "../formBuilders/formBuilderJsonSchema";
+// This accepts any as it is designed to consume directly from a json form
+export const generateFormSchema = (data) => {
+    // Wrapped with tc for now
+    try {
+        const ajv = new Ajv();
+        const validator = ajv.compile(FORM_BUILDER_JSON_SCHEMA);
+        if (!validator(data)) {
+            throw new Error("Data does not conform to a valid form schema");
+        }
+        console.log(data);
+        return data;
+    }
+    catch (e) {
+        return undefined;
+    }
+};
+// This needs to build the form schema, this is where custom field data schemas would be used, e.g. address should have a schema, which is utilised here to generate the form schema

package/dist/rendering/schema/generate/jsonSchemaGenerate.d.ts

@@ -0,0 +1,4 @@
+import { MasterSchema, Stage } from "../formSchemaTypes";
+import { JsonSchema } from "@jsonforms/core";
+import "../../prebuild/generated/import_generated";
+export declare const generateJsonSchema: (formSchema: MasterSchema, stage: Stage, onlyEditableFields?: boolean) => JsonSchema | undefined;

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

@@ -0,0 +1,61 @@
+import { getType } from "../../registry/fields";
+import { generateFieldId } from "../util";
+import "../../prebuild/generated/import_generated";
+export const generateJsonSchema = (formSchema, stage, onlyEditableFields) => {
+    // Lazy try catch rn
+    try {
+        const built = {
+            type: "object",
+            properties: {},
+            required: [],
+        };
+        formSchema.forEach(s => {
+            if (stage < s.existsFrom)
+                return;
+            if (onlyEditableFields && !s.editableIn.includes(stage))
+                return;
+            const fieldSchema = defaultConverter(s, stage);
+            built.properties[generateFieldId(s.name)] = fieldSchema;
+            if (s.required)
+                built.required.push(generateFieldId(s.name));
+        });
+        return built;
+    }
+    catch (e) {
+        console.error(e);
+        return undefined;
+    }
+};
+const defaultConverter = (field, stage, omitTitle, isChild) => {
+    var _a, _b, _c, _d, _e;
+    // Default field type
+    field.fieldType = (_a = field.fieldType) !== null && _a !== void 0 ? _a : "string";
+    let schema = getType(field.fieldType);
+    if (!schema)
+        throw new Error("tried to generate schema from unknown type: " + field.fieldType + "\nFull object: " + JSON.stringify(field, null, 2));
+    const requiredFields = [];
+    if (field.required)
+        requiredFields.push(field.name);
+    // Specific for array
+    let arrayItems = field.fieldType === "array" ? defaultConverter((_b = field.arrayOptions) === null || _b === void 0 ? void 0 : _b.itemDefinition, stage, true, true) : undefined;
+    // Obj childs
+    const properties = {};
+    for (const child of (_d = (_c = field.objectOptions) === null || _c === void 0 ? void 0 : _c.properties) !== null && _d !== void 0 ? _d : []) {
+        const fieldId = generateFieldId(child.name);
+        properties[fieldId] = defaultConverter(child, stage, false, true);
+        if (child.required)
+            requiredFields.push(fieldId);
+    }
+    // Enum fails if empty, fixes
+    let enumOpts = field.fieldType === "enum" ? (() => {
+        var _a;
+        let enumOptions = (((_a = field.enumOptions) === 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 }));
+};

package/dist/rendering/schema/generate/uiSchemaGenerate.d.ts

@@ -0,0 +1,3 @@
+import { Layout } from "@jsonforms/core";
+import { MasterSchema, Stage } from "../formSchemaTypes";
+export declare const generateUiSchema: (formSchema: MasterSchema, stage: Stage, onlyEditableFields?: boolean) => Layout;

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

@@ -0,0 +1,35 @@
+import { generateFieldId } from "../util";
+import { getAllTypes } from "../../registry/fields";
+export const generateUiSchema = (formSchema, stage, onlyEditableFields) => {
+    const uiSchema = { type: "VerticalLayout", elements: [] };
+    formSchema.forEach((field) => {
+        if (stage < field.existsFrom)
+            return;
+        if (onlyEditableFields && !field.editableIn.includes(stage))
+            return;
+        uiSchema.elements.push(uiFieldSchemaFromFieldDefinition(field));
+    });
+    return uiSchema;
+};
+const uiFieldSchemaFromFieldDefinition = (field, path = []) => {
+    var _a;
+    const scope = ["#", ...path, "properties", generateFieldId(field.name)].join("/");
+    if (field.fieldType !== "object" || getAllTypes().find((t => t.name === field.fieldType))) {
+        const uiElem = {
+            type: "Control",
+            scope,
+        };
+        return uiElem;
+    }
+    const children = ((_a = field.objectOptions) === null || _a === void 0 ? void 0 : _a.properties) || [];
+    const group = {
+        type: "Group",
+        label: field.name,
+        elements: children.map((child) => uiFieldSchemaFromFieldDefinition(child, [
+            ...path,
+            "properties",
+            generateFieldId(field.name),
+        ])),
+    };
+    return group;
+};

package/dist/rendering/schema/schema.d.ts

@@ -0,0 +1,48 @@
+export type JSONSchemaType = (JSONSchemaString | JSONSchemaNumber | JSONSchemaInteger | JSONSchemaBoolean | JSONSchemaEnum | JSONSchemaObject | JSONSchemaArray) & {
+    "x-type"?: string;
+};
+interface JSONSchemaBase {
+    title?: string;
+    description?: string;
+}
+export interface JSONSchemaString extends JSONSchemaBase {
+    type: "string";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: "" | "email" | "uri" | "date-time" | "date" | "time";
+    enum?: string[];
+}
+export interface JSONSchemaNumber extends JSONSchemaBase {
+    type: "number";
+    minimum?: number;
+    maximum?: number;
+    multipleOf?: number;
+}
+export interface JSONSchemaInteger extends JSONSchemaBase {
+    type: "integer";
+    minimum?: number;
+    maximum?: number;
+    multipleOf?: number;
+}
+export interface JSONSchemaBoolean extends JSONSchemaBase {
+    type: "boolean";
+}
+export interface JSONSchemaEnum extends JSONSchemaString {
+    enum: string[];
+}
+export interface JSONSchemaObject extends JSONSchemaBase {
+    type: "object";
+    properties: {
+        [key: string]: JSONSchemaType;
+    };
+    required?: string[];
+}
+export interface JSONSchemaArray extends JSONSchemaBase {
+    type: "array";
+    items: JSONSchemaType;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+}
+export {};

package/dist/rendering/schema/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/rendering/schema/template/constraint.d.ts

@@ -0,0 +1,17 @@
+import { JSONSchemaType } from "../schema";
+export type ConstraintType = "MustHaveOneOf" | "MustHaveAllOf" | "MustNotHave" | "Custom";
+export interface ConstraintDefinition {
+    type: ConstraintType;
+    name: string;
+    description: string;
+    schema: JSONSchemaType;
+    uiSchema: {
+        type: "VerticalLayout" | "HorizontalLayout";
+        elements: Array<{
+            type: "Control";
+            scope: string;
+            label?: string;
+        }>;
+    };
+}
+export declare const CONSTRAINT_DEFINITIONS: Record<ConstraintType, ConstraintDefinition>;

package/dist/rendering/schema/template/constraint.js

@@ -0,0 +1,119 @@
+export const CONSTRAINT_DEFINITIONS = {
+    MustHaveOneOf: {
+        type: "MustHaveOneOf",
+        name: "Must Have One Of",
+        description: "At least one of the specified templates must be present",
+        schema: {
+            type: "object",
+            properties: {
+                templateIds: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    minItems: 1,
+                },
+            },
+            required: ["templateIds"],
+        },
+        uiSchema: {
+            type: "VerticalLayout",
+            elements: [
+                {
+                    type: "Control",
+                    scope: "#/properties/templateIds",
+                    label: "Select Templates",
+                },
+            ],
+        },
+    },
+    MustHaveAllOf: {
+        type: "MustHaveAllOf",
+        name: "Must Have All Of",
+        description: "All of the specified templates must be present",
+        schema: {
+            type: "object",
+            properties: {
+                templateIds: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    minItems: 1,
+                },
+            },
+            required: ["templateIds"],
+        },
+        uiSchema: {
+            type: "VerticalLayout",
+            elements: [
+                {
+                    type: "Control",
+                    scope: "#/properties/templateIds",
+                    label: "Select Templates",
+                },
+            ],
+        },
+    },
+    MustNotHave: {
+        type: "MustNotHave",
+        name: "Must Not Have",
+        description: "None of the specified templates can be present",
+        schema: {
+            type: "object",
+            properties: {
+                templateIds: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    minItems: 1,
+                },
+            },
+            required: ["templateIds"],
+        },
+        uiSchema: {
+            type: "VerticalLayout",
+            elements: [
+                {
+                    type: "Control",
+                    scope: "#/properties/templateIds",
+                    label: "Select Templates",
+                },
+            ],
+        },
+    },
+    Custom: {
+        type: "Custom",
+        name: "Custom Constraint",
+        description: "Define a custom constraint with arbitrary fields",
+        schema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            required: ["name"],
+        },
+        uiSchema: {
+            type: "VerticalLayout",
+            elements: [
+                {
+                    type: "Control",
+                    scope: "#/properties/name",
+                    label: "Constraint Name",
+                },
+                {
+                    type: "Control",
+                    scope: "#/properties/parameters",
+                    label: "Parameters",
+                },
+            ],
+        },
+    },
+};

package/dist/rendering/schema/template/type.d.ts

@@ -0,0 +1,94 @@
+export interface FormBuilderSchema {
+    $schema: string;
+    type: "object";
+    properties: {
+        name: SchemaStringProperty;
+        formFields: RefArrayProperty;
+        ibFormFields: RefArrayProperty;
+        constraints: ConstraintArrayProperty;
+    };
+    required: string[];
+    $defs: {
+        fieldDefinition: DynamicFieldDefinition;
+        arrayItemDefinition: DynamicFieldDefinition;
+    };
+}
+export interface SchemaStringProperty {
+    type: "string";
+    minLength: number;
+    description: string;
+}
+export interface RefArrayProperty {
+    type: "array";
+    items: {
+        $ref: string;
+    };
+}
+export interface ConstraintArrayProperty {
+    type: "array";
+    items: ConstraintItem;
+}
+export interface ConstraintItem {
+    type: "object";
+    properties: {
+        type: {
+            type: "string";
+            enum: string[];
+            title: string;
+        };
+        [key: string]: any;
+    };
+    required: string[];
+    dependencies: {
+        type: {
+            oneOf: Array<{
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    [key: string]: any;
+                };
+                required: string[];
+            }>;
+        };
+    };
+}
+export interface DynamicFieldDefinition {
+    type: "object";
+    properties: {
+        fieldType: {
+            oneOf: Array<{
+                const: string;
+                title: string;
+            }>;
+        };
+        name?: {
+            type: "string";
+            minLength: number;
+            description?: string;
+        };
+        description?: {
+            type: "string";
+        };
+        required?: {
+            type: "boolean";
+            default: boolean;
+        };
+        [key: string]: any;
+    };
+    required: string[];
+    dependencies: {
+        fieldType: {
+            oneOf: Array<{
+                properties: {
+                    fieldType: {
+                        const?: string;
+                        enum?: string[];
+                    };
+                    [key: string]: any;
+                };
+                required?: string[];
+            }>;
+        };
+    };
+}

package/dist/rendering/schema/template/type.js

@@ -0,0 +1 @@
+export {};

package/dist/rendering/schema/util.d.ts

@@ -0,0 +1 @@
+export declare function generateFieldId(name: string): string;

package/dist/rendering/schema/util.js

@@ -0,0 +1,22 @@
+// Helper function to generate field ID from name
+export function generateFieldId(name) {
+    if (!name)
+        return `field_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+    return toCamelCase(name);
+}
+// ??
+const toCamelCase = (str) => {
+    if (!str || typeof str !== "string") {
+        return `field_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+    }
+    return (str
+        .replace(/\s(.)/g, function ($1) {
+        return $1.toUpperCase();
+    })
+        .replace(/\s/g, "")
+        .replace(/^(.)/, function ($1) {
+        return $1.toLowerCase();
+    })
+        .replace(/[^a-zA-Z0-9_]/g, "") ||
+        `field_${Date.now()}_${Math.floor(Math.random() * 1000)}`);
+};

package/dist/rendering/type_registration/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rendering/type_registration/register.js

@@ -0,0 +1,139 @@
+import { registerType } from "../registry/fields";
+registerType("string", "Text", { type: "string" }, {
+    type: "object",
+    title: "Text Options",
+    properties: {
+        minLength: { type: "integer", minimum: 0 },
+        maxLength: { type: "integer", minimum: 1 },
+        pattern: { type: "string" },
+        format: {
+            type: "string",
+            enum: ["", "email", "uri", "date-time", "date", "time"],
+        },
+    },
+}, false);
+registerType("number", "Number", { type: "number" }, {
+    type: "object",
+    properties: {
+        minimum: { type: "number" },
+        maximum: { type: "number" },
+        multipleOf: { type: "number", exclusiveMinimum: 0 },
+    },
+}, false);
+registerType("integer", "Integer", { type: "integer" }, {
+    type: "object",
+    properties: {
+        minimum: { type: "number" },
+        maximum: { type: "number" },
+        multipleOf: { type: "number", exclusiveMinimum: 0 },
+    },
+}, false);
+registerType("boolean", "Checkbox", { type: "boolean" }, {}, false);
+registerType("enum", "Dropdown", { 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",
+    properties: {
+        minItems: { type: "integer", minimum: 0 },
+        maxItems: { type: "integer", minimum: 1 },
+        uniqueItems: { type: "boolean", default: false },
+        itemDefinition: { $ref: "#/$defs/arrayItemDefinition" },
+    },
+}, true);
+registerType("object", "Group", { type: "object" }, {
+    type: "object",
+    title: "Group",
+    properties: {
+        properties: {
+            type: "array",
+            title: "Group Fields",
+            items: { $ref: "#/$defs/fieldDefinition" },
+        },
+    },
+}, true);
+registerType("stagedText", "Staged Text", {}, {}, false);
+registerType("liveData", "Live Data", {}, {}, false);
+registerType("component", "Component Reference", {}, {
+    "x-type": "componentOptions",
+    type: "object",
+    title: "Component Options",
+    properties: {
+        templateIds: {
+            type: "array",
+            title: "Select Templates",
+            items: {
+                type: "string",
+            },
+        },
+    },
+}, false);
+registerType("example", "Example Field", { type: "string" }, {
+    type: "object",
+    title: "Example Options",
+    properties: {
+        exampleTextInput: { type: "string" },
+    },
+}, false);
+registerType("address", "Address", {
+    title: "your address",
+    description: "your address",
+    type: "object",
+    properties: {
+        line1: {
+            type: "string",
+            title: "Address Line 1"
+        },
+        line2: {
+            type: "string",
+            title: "Address Line 2"
+        },
+        city: {
+            type: "string",
+            title: "City"
+        },
+        county: {
+            type: "string",
+            title: "County"
+        },
+        postcode: {
+            type: "string",
+            title: "Postcode",
+            pattern: "^[A-Z]{1,2}[0-9][0-9A-Z]? ?[0-9][A-Z]{2}$"
+        },
+        number: {
+            type: "number",
+            title: "Number"
+        }
+    },
+    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/dist/rendering/types/address.d.ts

@@ -0,0 +1,10 @@
+export type Address = UKAddress;
+interface UKAddress {
+    line1: string;
+    line2?: string;
+    city: string;
+    county?: string;
+    postcode: string;
+    number?: number;
+}
+export {};

package/dist/rendering/types/address.js

@@ -0,0 +1 @@
+export {};

package/dist/rendering/types/jsonSchema.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchema } from "@jsonforms/core";
+export type JsonSchemaWithXType = JsonSchema & {
+    "x-type"?: string;
+};

package/dist/rendering/types/jsonSchema.js

@@ -0,0 +1 @@
+export {};

package/dist/rendering/types/util.d.ts

@@ -0,0 +1 @@
+export type Updator<T extends object> = <Field extends keyof T>(field: Field, value: T[Field]) => void;

package/dist/rendering/types/util.js

@@ -0,0 +1 @@
+export {};

package/dist/rendering/util/string.d.ts

@@ -0,0 +1 @@
+export declare const capitalise: (str: string) => string;

package/dist/rendering/util/string.js

@@ -0,0 +1 @@
+export const capitalise = (str) => str.charAt(0).toUpperCase() + str.slice(1);

package/dist/rendering/util/xtype.d.ts

@@ -0,0 +1,3 @@
+import { JsonSchema, RankedTester } from "@jsonforms/core";
+export declare const getXType: (schema: JsonSchema) => string | undefined;
+export declare const isXType: (type: string) => RankedTester;

package/dist/rendering/util/xtype.js

@@ -0,0 +1,18 @@
+import { resolveSchema } from "@jsonforms/core";
+export const getXType = (schema) => {
+    let typed = schema;
+    if (!typed)
+        return undefined;
+    return typed["x-type"];
+};
+export const isXType = (type) => {
+    return (uischema, schema, ctx) => {
+        const ui = uischema;
+        if (!ui.scope)
+            return -1;
+        const scoped = resolveSchema(schema, ui.scope, schema);
+        if (getXType(scoped) === type)
+            return 10;
+        return -1;
+    };
+};

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};