swoop-common 1.0.43 → 2.0.1

package/dist/api/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./generated/core/exports";
+export * from "./generated/swoop/exports";
+export { init } from "./init";

package/dist/api/index.js

@@ -0,0 +1,5 @@
+// API SDKs //
+export * from "./generated/core/exports";
+//export * from "./api/generated/itinerary/exports" Nothing exported directly
+export * from "./generated/swoop/exports";
+export { init } from "./init";

package/dist/api/init.d.ts

@@ -0,0 +1,18 @@
+import * as Core from "./generated/core/index";
+import * as Itinerary from "./generated/itinerary/index";
+import * as Swoop from "./generated/swoop/index";
+export declare const services: {
+    SwoopService: Swoop.SwoopService;
+    CoreService: Core.CoreService;
+    ItineraryService: Itinerary.ItineraryService;
+};
+export declare const init: (opts: {
+    itineraryServiceUrl: string;
+    coreServiceUrl: string;
+    swoopServiceForwardUrl: string;
+}) => {
+    SwoopService: Swoop.SwoopService;
+    CoreService: Core.CoreService;
+    ItineraryService: Itinerary.ItineraryService;
+};
+export declare const initialisedCheck: () => void;

package/dist/api/init.js

@@ -0,0 +1,29 @@
+import * as Core from "./generated/core/index";
+import * as Itinerary from "./generated/itinerary/index";
+import * as Swoop from "./generated/swoop/index";
+let initalised = false;
+export const services = {
+    SwoopService: new Swoop.SwoopService(),
+    CoreService: new Core.CoreService(),
+    ItineraryService: new Itinerary.ItineraryService(),
+};
+export const init = (opts) => {
+    // Keeps it consitent
+    if (opts.coreServiceUrl.endsWith("/"))
+        opts.coreServiceUrl = opts.coreServiceUrl.slice(0, -1);
+    if (opts.itineraryServiceUrl.endsWith("/"))
+        opts.itineraryServiceUrl = opts.itineraryServiceUrl.slice(0, -1);
+    if (opts.swoopServiceForwardUrl.endsWith("/"))
+        opts.swoopServiceForwardUrl = opts.swoopServiceForwardUrl.slice(0, -1);
+    // Update
+    Core.OpenAPI.BASE = opts.coreServiceUrl;
+    Itinerary.OpenAPI.BASE = opts.itineraryServiceUrl;
+    Swoop.OpenAPI.BASE = opts.swoopServiceForwardUrl;
+    initalised = true;
+    return services;
+};
+export const initialisedCheck = () => {
+    if (initalised)
+        return;
+    console.warn("swoop-common has been used without being initialised. The library will continue to work in some cases, but requests will fail. Use init() to initialise the library.");
+};

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

@@ -0,0 +1,39 @@
+import React from 'react';
+import { ComponentPool } from '../registry/types';
+import { MasterSchema, Stage } from '../schema/formSchemaTypes';
+interface Props {
+    /**
+     * 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.
+     */
+    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.
+     */
+    onChange?: (value: any) => void;
+    /**
+     * Dictates which mode the form will display in.
+     * Each mode has a different pool of renderers.
+     */
+    pool: ComponentPool;
+    /**
+     * Whether this form should be readonly.
+     * Has little to no effect if using the presentation pool of components
+     */
+    readonly?: boolean;
+    /**
+     * The stage at which to render this template
+     */
+    stage: Stage;
+    /**
+     * Should readonly fields be hidden
+     */
+    hideReadonlyFields?: boolean;
+}
+export declare const StyledFormView: React.FC<Props>;
+export {};

package/dist/rendering/components/StyledFormView.js

@@ -0,0 +1,13 @@
+import { JsonForms } from '@jsonforms/react';
+import React, { useEffect } from 'react';
+import { materialCells, materialRenderers } from '@jsonforms/material-renderers';
+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 }) => {
+    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 }));
+};

package/dist/rendering/hooks/errors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns a function which can be used to retrieve errors.
+ * For objects field is the field name.
+ * For primitives field is the x-type.
+ */
+export declare const useLocalErrors: (path: string) => (field: string) => import("ajv").ErrorObject<string, Record<string, any>, unknown> | undefined;

package/dist/rendering/hooks/errors.js

@@ -0,0 +1,17 @@
+import { useJsonForms } from "@jsonforms/react";
+import React from "react";
+/**
+ * Returns a function which can be used to retrieve errors.
+ * For objects field is the field name.
+ * For primitives field is the x-type.
+ */
+export const useLocalErrors = (path) => {
+    const { core } = useJsonForms();
+    console.log(core);
+    // Filters out errors for the current scope
+    const local = React.useMemo(() => {
+        var _a;
+        return ((_a = core === null || core === void 0 ? void 0 : core.errors) === null || _a === void 0 ? void 0 : _a.filter(e => e.instancePath.startsWith("/" + path.replace(/\./g, "/")))) || [];
+    }, [core === null || core === void 0 ? void 0 : core.errors, path]);
+    return React.useCallback((field) => local.find(e => e.instancePath.endsWith("/" + field)), [local]);
+};

package/dist/rendering/index.d.ts

@@ -0,0 +1,11 @@
+import "./prebuild/generated/import_generated";
+import "../api/init";
+export { getComponents } from "./registry/components";
+export { JSONSchemaObject } from "./schema/schema";
+export { generateUiSchema } from "./schema/generate/uiSchemaGenerate";
+export { generateJsonSchema } from "./schema/generate/jsonSchemaGenerate";
+export * from "./components/StyledFormView";
+export * from "./registry/types";
+export { MasterSchema, Stage } from "./schema/formSchemaTypes";
+export { FORM_BUILDER_JSON_SCHEMA } from "./schema/formBuilders/formBuilderJsonSchema";
+export { FORM_BUILDER_UI_SCHEMA } from "./schema/formBuilders/formBuilderUiSchema";

package/dist/rendering/index.js

@@ -0,0 +1,11 @@
+import "./prebuild/generated/import_generated";
+import "../api/init";
+// RENDERING //
+export { getComponents } from "./registry/components";
+export { generateUiSchema } from "./schema/generate/uiSchemaGenerate";
+export { generateJsonSchema } from "./schema/generate/jsonSchemaGenerate";
+export * from "./components/StyledFormView";
+export * from "./registry/types";
+export { Stage } from "./schema/formSchemaTypes";
+export { FORM_BUILDER_JSON_SCHEMA } from "./schema/formBuilders/formBuilderJsonSchema";
+export { FORM_BUILDER_UI_SCHEMA } from "./schema/formBuilders/formBuilderUiSchema";

package/dist/rendering/prebuild/generated/import_generated.d.ts

@@ -0,0 +1,13 @@
+import "../../type_registration/register";
+import "../../renderers/Address";
+import "../../renderers/ComponentPicker";
+import "../../renderers/Debug";
+import "../../renderers/Example";
+import "../../renderers/Image/ImageForm";
+import "../../renderers/Image/ImagePresentation";
+import "../../renderers/StagedText";
+import "../../renderers/TemplatePicker";
+import "../../renderers/textfield/MultilineForm";
+import "../../renderers/textfield/MultilinePresentation";
+import "../../schema/formBuilders/formBuilderJsonSchema";
+import "../../schema/formBuilders/formBuilderUiSchema";

package/dist/rendering/prebuild/generated/import_generated.js

@@ -0,0 +1,16 @@
+// Base field types
+import "../../type_registration/register";
+// Custom component renderers
+import "../../renderers/Address";
+import "../../renderers/ComponentPicker";
+import "../../renderers/Debug";
+import "../../renderers/Example";
+import "../../renderers/Image/ImageForm";
+import "../../renderers/Image/ImagePresentation";
+import "../../renderers/StagedText";
+import "../../renderers/TemplatePicker";
+import "../../renderers/textfield/MultilineForm";
+import "../../renderers/textfield/MultilinePresentation";
+// Build template from schema last
+import "../../schema/formBuilders/formBuilderJsonSchema";
+import "../../schema/formBuilders/formBuilderUiSchema";

package/dist/rendering/prebuild/import.d.ts

@@ -0,0 +1 @@
+export declare function getFilesRec(dir: string): string[];

package/dist/rendering/prebuild/import.js

@@ -0,0 +1,32 @@
+import fs from "fs";
+import path from "path";
+// Using codegen here as it reduces the number of files required to edit to add a new component.
+// It also ensures import order, which is important as types must be registered before any form schema is generated (this is generated at load, once)
+export function getFilesRec(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    return entries.flatMap((entry) => {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            return getFilesRec(fullPath);
+        else
+            return fullPath;
+    });
+}
+const getImports = (base) => {
+    const files = getFilesRec(base).filter(f => f.endsWith(".tsx"));
+    const renderers = files.map((file) => {
+        const relativePath = path.relative(base, file);
+        const noExt = relativePath.replace(/\.[^/.]+$/, '');
+        const normalized = noExt.split(path.sep).join('/');
+        return `import "../../renderers/${normalized}"`;
+    });
+    const templateFormSchemas = [`import "../../schema/formBuilders/formBuilderJsonSchema"`, `import "../../schema/formBuilders/formBuilderUiSchema"`];
+    const baseFieldTypes = `import "../../type_registration/register"`;
+    return [
+        "// Base field types", baseFieldTypes, "",
+        "// Custom component renderers",
+        ...renderers, "",
+        "// Build template from schema last", ...templateFormSchemas
+    ];
+};
+fs.writeFileSync("./src/rendering/prebuild/generated/import_generated.ts", getImports("./src/rendering/renderers").join("\n"));

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

@@ -0,0 +1,13 @@
+import { ControlProps, OwnPropsOfControl, RankedTester } from "@jsonforms/core";
+import { ComponentType } from "react";
+import { ComponentPool } from "./types";
+export interface CustomTypeData extends CustomTypeComponent {
+}
+interface CustomTypeComponent {
+    tester: RankedTester;
+    renderer: ComponentType<OwnPropsOfControl>;
+}
+export declare const registerComponent: (xType: string, Renderer: ComponentType<ControlProps>, mode: ComponentPool, overrideTester?: RankedTester) => void;
+export declare const getComponents: (mode: ComponentPool) => Readonly<Array<CustomTypeComponent>>;
+export declare const getComponent: (mode: ComponentPool, xType: string) => CustomTypeComponent | undefined;
+export {};

package/dist/rendering/registry/components.js

@@ -0,0 +1,49 @@
+import { withJsonFormsControlProps } from "@jsonforms/react";
+import React from "react";
+import { isXType } from "../util/xtype";
+import { ComponentPool } from "./types";
+// Stored seperately to avoid more expensive lookups
+const componentRegistry = {
+    [ComponentPool.FORM]: new Map(),
+    [ComponentPool.PRESENTATION]: new Map()
+};
+export const registerComponent = (xType, Renderer, mode, overrideTester) => {
+    if (overrideTester) {
+        componentRegistry[mode].set(xType, {
+            tester: overrideTester,
+            renderer: withJsonFormsControlProps(Renderer)
+        });
+        return;
+    }
+    if (componentRegistry[mode].has(xType)) {
+        console.error("Tried to register duplicate component name:", xType);
+        return;
+    }
+    // Wrap the component in a visibility checker
+    const wrapped = (props) => {
+        if (!props.visible)
+            return null;
+        return React.createElement(Renderer, Object.assign({}, props));
+    };
+    componentRegistry[mode].set(xType, {
+        tester: isXType(xType),
+        renderer: withJsonFormsControlProps(wrapped)
+    });
+};
+export const getComponents = (mode) => {
+    const list = [...componentRegistry[mode].values()];
+    return (list.map(c => ({ renderer: c.renderer, tester: c.tester })));
+};
+export const getComponent = (mode, xType) => {
+    const comp = componentRegistry[mode].get(xType);
+    if (!comp)
+        return undefined;
+    return ({ tester: comp.tester, renderer: comp.renderer });
+};
+/*
+export const genComponentSchema = (mode: ComponentPool, xType: string): ComponentDataSchema | undefined =>
+{
+    const comp = componentRegistry[mode].get(xType)
+    if (!comp) return undefined;
+    return structuredClone(comp.schema);
+}*/ 

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

@@ -0,0 +1,10 @@
+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 getAllTypes: () => Array<TemplateField>;
+export declare const getType: (xType: string) => TemplateField | undefined;

package/dist/rendering/registry/fields.js

@@ -0,0 +1,19 @@
+const typeRegistry = new Map();
+/**
+ * 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 const registerType = (name, title, schema, options, optionsRequired) => {
+    if (typeRegistry.has(name)) {
+        console.error("Tried to register duplicate name:", name);
+        return;
+    }
+    const withXType = Object.assign({ "x-type": name }, schema);
+    typeRegistry.set(name, { name, title, options, optionsRequired, schema: withXType });
+};
+export const getAllTypes = () => {
+    return structuredClone([...typeRegistry.values()]);
+};
+export const getType = (xType) => {
+    return structuredClone(typeRegistry.get(xType));
+};

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

@@ -0,0 +1,5 @@
+export declare enum ComponentPool {
+    PRESENTATION = 0,
+    FORM = 1
+}
+export type ComponentDataSchema = object;

package/dist/rendering/registry/types.js

@@ -0,0 +1,5 @@
+export var ComponentPool;
+(function (ComponentPool) {
+    ComponentPool[ComponentPool["PRESENTATION"] = 0] = "PRESENTATION";
+    ComponentPool[ComponentPool["FORM"] = 1] = "FORM";
+})(ComponentPool || (ComponentPool = {}));

package/dist/rendering/renderers/Address.d.ts

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

package/dist/rendering/renderers/Address.js

@@ -0,0 +1,67 @@
+'use client';
+import React, { useEffect, useMemo, useState } from 'react';
+import { Paper, Typography, TextField, Grid, Divider } from '@mui/material';
+import { registerComponent } from '../registry/components';
+import { ComponentPool } from '../registry/types';
+const FormAddress = ({ data, onChange, enabled, label, postcodePattern }) => {
+    var _a;
+    const [postcodeInvalid, setPostcodeInvalid] = useState(false);
+    const [postcodeHelperText, setPostcodeHelperText] = useState('');
+    const validatePostcode = (value) => {
+        if (!value)
+            return true;
+        const regex = new RegExp(postcodePattern || '^[A-Z]{1,2}[0-9][0-9A-Z]? ?[0-9][A-Z]{2}$', 'i');
+        return regex.test(value);
+    };
+    const handlePostcodeChange = (value) => {
+        const valid = validatePostcode(value);
+        setPostcodeInvalid(!valid);
+        setPostcodeHelperText(valid ? '' : 'Please enter a valid postcode (e.g., SW1A 1AA)');
+        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 },
+            React.createElement(Grid, { item: true, xs: 12 },
+                React.createElement(TextField, { fullWidth: true, label: "Address Line 1", value: data.line1 || '', onChange: (e) => onChange('line1', e.target.value), disabled: !enabled, required: true })),
+            React.createElement(Grid, { item: true, xs: 12 },
+                React.createElement(TextField, { fullWidth: true, label: "Address Line 2", value: data.line2 || '', onChange: (e) => onChange('line2', e.target.value), disabled: !enabled })),
+            React.createElement(Grid, { item: true, xs: 12, sm: 6 },
+                React.createElement(TextField, { fullWidth: true, label: "City", value: data.city || '', onChange: (e) => onChange('city', e.target.value), disabled: !enabled, required: true })),
+            React.createElement(Grid, { item: true, xs: 12, sm: 6 },
+                React.createElement(TextField, { fullWidth: true, label: "County", value: data.county || '', onChange: (e) => onChange('county', e.target.value), disabled: !enabled })),
+            React.createElement(Grid, { item: true, xs: 12, sm: 6 },
+                React.createElement(TextField, { fullWidth: true, label: "Postcode", value: data.postcode || '', onChange: (e) => handlePostcodeChange(e.target.value), error: postcodeInvalid, helperText: postcodeHelperText, disabled: !enabled, required: true })),
+            React.createElement(Grid, { item: true, xs: 12, sm: 6 },
+                React.createElement(TextField, { fullWidth: true, label: "Number", type: "number", value: (_a = data.number) !== null && _a !== void 0 ? _a : '', onChange: (e) => onChange('number', e.target.value === '' ? '' : Number(e.target.value)), disabled: !enabled }))),
+        React.createElement(Divider, null),
+        React.createElement(Typography, { variant: "subtitle1" }, "Location Preview"),
+        React.createElement("div", { style: {
+                height: '250px',
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                border: '1px solid #ccc',
+                borderRadius: '8px',
+                fontSize: '0.9rem',
+                color: '#777'
+            } }, "[Map Placeholder]")));
+};
+const FormRendererAddress = ({ data, handleChange, path, enabled, label, schema }) => {
+    var _a, _b;
+    const safeData = data || {
+        line1: '', line2: '', city: '', county: '', postcode: '', number: undefined
+    };
+    const postcodePattern = ((_b = (_a = schema === null || schema === void 0 ? void 0 : schema.properties) === null || _a === void 0 ? void 0 : _a.postcode) === null || _b === void 0 ? void 0 : _b.pattern) || undefined;
+    const handleFieldChange = (key, value) => {
+        handleChange(`${path}.${key}`, value);
+    };
+    return (React.createElement(FormAddress, { data: safeData, onChange: handleFieldChange, enabled: enabled, label: label, postcodePattern: postcodePattern }));
+};
+registerComponent("address", FormRendererAddress, ComponentPool.FORM);

package/dist/rendering/renderers/ComponentPicker.d.ts

@@ -0,0 +1,20 @@
+import { DTOComponentRead } from '../../api/generated/core/exports';
+export declare const fetchComponents: () => Promise<{
+    data: {
+        revisions: DTOComponentRead[];
+        id: string;
+        templateId: string;
+        revisionGroupId: string;
+        revision: number;
+        metadata: import("../../api/generated/core/exports").Metadata;
+        name: string;
+        componentFields: Array<import("../../api/generated/core/exports").Field>;
+        partners: Array<string>;
+        bundle: Array<import("../../api/generated/core/exports").Bundle>;
+        startDate?: string | null;
+        endDate?: string | null;
+        duration?: number | null;
+        details: import("../../api/generated/core/exports").ComponentDetails;
+        state?: string | null;
+    }[];
+}>;

package/dist/rendering/renderers/ComponentPicker.js

@@ -0,0 +1,67 @@
+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, useMemo, useState } from 'react';
+import { Paper, Typography, Box, TextField, Autocomplete } from '@mui/material';
+import { useLocalErrors } from '../hooks/errors';
+import { ComponentPool } from '../registry/types';
+import { registerComponent } from '../registry/components';
+import { services } from '../../api/init';
+const FormComponentPicker = ({ components, selectedComponent, onChange, templateIds, getError, label, enabled }) => {
+    const selected = components.find(c => c.id === selectedComponent) || null;
+    return (React.createElement(Paper, { component: "form", sx: { display: 'flex', flexDirection: 'column', gap: 1, p: 2, mb: 1 }, noValidate: true, autoComplete: "off" },
+        React.createElement(Typography, { variant: 'h6' }, label),
+        React.createElement(Autocomplete, { options: components, getOptionLabel: (option) => option.name, getOptionKey: o => o.id, value: selected, onChange: (_, newValue) => onChange(newValue ? newValue.id : null), renderInput: (params) => (React.createElement(TextField, Object.assign({}, params, { variant: "outlined", placeholder: "Search and select a component", disabled: !enabled }))), renderOption: (props, option) => (React.createElement("li", Object.assign({}, props),
+                React.createElement(Box, null,
+                    React.createElement(Typography, { variant: "body1" }, option.name),
+                    React.createElement(Typography, { variant: "caption", color: "text.secondary" },
+                        "Version: v",
+                        option.revision)))), isOptionEqualToValue: (option, value) => option.id === value.id })));
+};
+const FormRendererComponentPicker = ({ data, handleChange, path, label, enabled, schema }) => {
+    const [components, setComponents] = useState([]);
+    const getError = useLocalErrors(path);
+    const templateIds = useMemo(() => 
+    // @ts-ignore
+    schema['x-templateIds'] || [], [schema]);
+    useEffect(() => {
+        const load = () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const fetched = yield fetchComponents();
+                let filtered = fetched.data;
+                if (templateIds.length > 0) {
+                    filtered = filtered.filter(c => templateIds.includes(c.templateId));
+                }
+                setComponents(filtered);
+            }
+            catch (err) {
+                console.error('Error loading components:', err);
+            }
+        });
+        load();
+    }, [templateIds]);
+    return (React.createElement(FormComponentPicker, { components: components, selectedComponent: data || null, onChange: (id) => handleChange(path, id), templateIds: templateIds, getError: getError, label: label, enabled: enabled }));
+};
+registerComponent("component", FormRendererComponentPicker, ComponentPool.FORM);
+export const fetchComponents = () => __awaiter(void 0, void 0, void 0, function* () {
+    const componentsByGroup = new Map();
+    const data = yield services.CoreService.componentList(1, 1000);
+    (data.data || []).forEach((component) => {
+        const groupId = component.revisionGroupId;
+        if (!componentsByGroup.has(groupId)) {
+            componentsByGroup.set(groupId, []);
+        }
+        componentsByGroup.get(groupId).push(component);
+    });
+    const latestComponents = Array.from(componentsByGroup.values()).map((components) => {
+        const sortedComponents = components.sort((a, b) => b.revision - a.revision);
+        return Object.assign(Object.assign({}, sortedComponents[0]), { revisions: sortedComponents });
+    });
+    return { data: latestComponents };
+});

package/dist/rendering/renderers/Debug.d.ts

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

package/dist/rendering/renderers/Debug.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import { Paper, TextField, Typography } from '@mui/material';
+const FormDebug = ({ path, label }) => {
+    return (React.createElement(Paper, { component: "form", sx: { display: 'flex', flexDirection: 'column', gap: 1, p: 2, background: "#CBC3E3", mb: 1 }, noValidate: true, autoComplete: "off" },
+        React.createElement(Typography, { variant: 'h6' }, label),
+        React.createElement(TextField, { label: "Path", value: path })));
+};
+const FormRendererDebug = ({ path, label }) => {
+    return React.createElement(FormDebug, { label: label, path: path });
+};
+// Will render any components if they do not have a renderer, for testing
+//registerComponent("", FormRendererDebug, ComponentPool.FORM, () => 1)
+//registerComponent("", FormRendererDebug, ComponentPool.PRESENTATION, () => 1)

package/dist/rendering/renderers/Example.d.ts

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

package/dist/rendering/renderers/Example.js

@@ -0,0 +1,31 @@
+import React, { useMemo, useState } from 'react';
+import { debounce, Paper, TextField, Typography } from '@mui/material';
+import { useLocalErrors } from '../hooks/errors';
+import { ComponentPool } from '../registry/types';
+import { registerComponent } from '../registry/components';
+// The base component used to render. Can be exported for external use
+const FormExample = ({ text, onChange, getError, label, enabled }) => {
+    var _a;
+    const [val, setVal] = useState(text);
+    // Gets any error associated with this component. If there are multiple, it gets the first
+    const error = getError ? (_a = getError("example")) === null || _a === void 0 ? void 0 : _a.message : undefined;
+    const onChangeDebounced = useMemo(() => debounce(onChange, 300), [onChange]);
+    // Handle internal state, and debounce submission to avoid constant validations
+    const update = (value) => {
+        setVal(value);
+        onChangeDebounced(value);
+    };
+    return (React.createElement(Paper, { component: "form", sx: { display: 'flex', flexDirection: 'column', gap: 1, p: 2, background: "#CBC3E3", mb: 1 }, noValidate: true, autoComplete: "off" },
+        !enabled && "THIS IS DISABLED",
+        React.createElement(Typography, { variant: 'h6' }, label),
+        React.createElement(TextField, { label: "Example label", value: val, onChange: (e) => update(e.target.value), error: !!error, helperText: error, disabled: !enabled })));
+};
+// Wrapper component for converting the base component into a jsonforms compatible version
+const FormRendererExample = ({ data, handleChange, path, label, enabled }) => {
+    const getError = useLocalErrors(path);
+    return React.createElement(FormExample, { text: data, onChange: (addr) => handleChange(path, addr), getError: getError, label: label, enabled: enabled });
+};
+// Register this component for x-type: example
+// Register this component for all form modes
+registerComponent("example", FormRendererExample, ComponentPool.FORM);
+registerComponent("example", FormRendererExample, ComponentPool.PRESENTATION);

package/dist/rendering/renderers/Image/ImageForm.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ErrorObject } from "ajv";
+interface Props {
+    url: string;
+    onChange: (string: string) => void;
+    getError?: (field: string) => ErrorObject<string, Record<string, any>, unknown> | undefined;
+    enabled: boolean;
+}
+declare const FormImage: React.FC<Props>;
+export default FormImage;