@json-layout/vocabulary 1.4.1 → 1.4.2

package/types/normalize.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {string | number} key
+ * @param {SchemaFragment} schemaFragment
+ * @param {string} schemaPath
+ * @param {Record<string, import('./types.js').ComponentInfo>} components
+ * @param {(text: string) => string} markdown
+ * @param {Array<'help' | 'hint' | 'subtitle'>} useDescription
+ * @param {string[]} [optionsKeys]
+ * @param {'oneOf' | 'patternProperties'} [schemaChild]
+ * @param {string | undefined} [knownType]
+ * @param {boolean} [knownNullable]
+ * @returns {{layout: NormalizedLayout, errors: string[]}}
+ */
+export function normalizeLayoutFragment(key: string | number, schemaFragment: SchemaFragment, schemaPath: string, components: Record<string, import("./types.js").ComponentInfo>, markdown: ((text: string) => string) | undefined, useDescription: Array<"help" | "hint" | "subtitle">, optionsKeys?: string[], schemaChild?: "oneOf" | "patternProperties", knownType?: string | undefined, knownNullable?: boolean): {
+    layout: NormalizedLayout;
+    errors: string[];
+};
+export function getSchemaFragmentType(schemaFragment: SchemaFragment): {
+    type: string | undefined;
+    nullable: boolean;
+};
+export type Child = import("./index.js").Child;
+export type Children = import("./index.js").Children;
+export type BaseCompObject = import("./index.js").BaseCompObject;
+export type Expression = import("./index.js").Expression;
+export type NormalizedLayout = import("./index.js").NormalizedLayout;
+export type LayoutKeyword = import("./index.js").LayoutKeyword;
+export type PartialChildren = import("./index.js").PartialChildren;
+export type PartialCompObject = import("./index.js").PartialCompObject;
+export type SchemaFragment = import("./types.js").SchemaFragment;
+//# sourceMappingURL=normalize.d.ts.map

package/types/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../src/normalize.js"],"names":[],"mappings":"AAwoBA;;;;;;;;;;;;GAYG;AACH,6CAZW,MAAM,GAAG,MAAM,kBACf,cAAc,cACd,MAAM,cACN,MAAM,CAAC,MAAM,EAAE,OAAO,YAAY,EAAE,aAAa,CAAC,aAClD,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,+BACxB,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC,gBACnC,MAAM,EAAE,gBACR,OAAO,GAAG,mBAAmB,cAC7B,MAAM,GAAG,SAAS,kBAClB,OAAO,GACL;IAAC,MAAM,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAC,CAuBxD;AAjYM,sDAHI,cAAc,GACZ;IAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAC,CA+BzD;oBAjUY,OAAO,YAAY,EAAE,KAAK;uBAC1B,OAAO,YAAY,EAAE,QAAQ;6BAC7B,OAAO,YAAY,EAAE,cAAc;yBACnC,OAAO,YAAY,EAAE,UAAU;+BAC/B,OAAO,YAAY,EAAE,gBAAgB;4BACrC,OAAO,YAAY,EAAE,aAAa;8BAClC,OAAO,YAAY,EAAE,eAAe;gCACpC,OAAO,YAAY,EAAE,iBAAiB;6BACtC,OAAO,YAAY,EAAE,cAAc"}

package/types/normalized-layout/index.d.ts

@@ -0,0 +1,66 @@
+export function isSwitchStruct(layout: NormalizedLayout): layout is SwitchStruct;
+export function isCompObject(layout: NormalizedLayout): layout is BaseCompObject;
+export function childIsCompositeCompObject(child: Child): child is Child & CompositeCompObject;
+export function childIsSlotCompObject(child: Child): child is Child & SlotCompObject;
+export function isCompositeLayout(layout: BaseCompObject, components: Record<string, import("../types.js").ComponentInfo>): layout is CompositeCompObject;
+export function isListLayout(layout: BaseCompObject): layout is import("../components/types.js").List;
+export function isFocusableLayout(layout: BaseCompObject, components: Record<string, import("../types.js").ComponentInfo>): layout is FocusableCompObject;
+export function isItemsLayout(layout: BaseCompObject, components: Record<string, import("../types.js").ComponentInfo>): layout is ItemsBasedCompObject;
+export function isGetItemsExpression(getItems: GetItems): getItems is Expression;
+export function isGetItemsFetch(getItems: GetItems): getItems is GetItemsFetch;
+export function isTextSlot(slot: Slot): slot is {
+    text: string;
+};
+export function isMarkdownSlot(slot: Slot): slot is {
+    markdown: string;
+};
+export function isNameSlot(slot: Slot): slot is {
+    name: string;
+};
+/**
+ * @typedef {import('./types.js').NormalizedLayout} NormalizedLayout
+ * @typedef {import('./types.js').SwitchStruct} SwitchStruct
+ * @typedef {import('./types.js').BaseCompObject} BaseCompObject
+ * @typedef {import('./types.js').SelectItem} SelectItem
+ * @typedef {import('./types.js').SelectItems} SelectItems
+ * @typedef {import('./types.js').GetItemsFetch} GetItemsFetch
+ * @typedef {import('./types.js').Child} Child
+ * @typedef {import('./types.js').Children} Children
+ * @typedef {import('./types.js').ChildSlot} ChildSlot
+ * @typedef {import('./types.js').CompositeCompObject} CompositeCompObject
+ * @typedef {import('./types.js').SlotCompObject} SlotCompObject
+ * @typedef {import('./types.js').ItemsBasedCompObject} ItemsBasedCompObject
+ * @typedef {import('./types.js').FocusableCompObject} FocusableCompObject
+ * @typedef {import('./types.js').GetItems} GetItems
+ * @typedef {import('./types.js').Expression} Expression
+ * @typedef {import('./types.js').Cols} Cols
+ * @typedef {import('./types.js').ColsObj} ColsObj
+ * @typedef {import('./types.js').StateNodeOptionsBase} StateNodeOptionsBase
+ * @typedef {import('./types.js').StateNodePropsLib} StateNodePropsLib
+ * @typedef {import('./types.js').Slot} Slot
+ * @typedef {import('./types.js').Slots} Slots
+ */
+export const validateNormalizedLayout: import("../types.js").ValidateNormalizedLayout;
+export const normalizedLayoutSchema: any;
+export type NormalizedLayout = import("./types.js").NormalizedLayout;
+export type SwitchStruct = import("./types.js").SwitchStruct;
+export type BaseCompObject = import("./types.js").BaseCompObject;
+export type SelectItem = import("./types.js").SelectItem;
+export type SelectItems = import("./types.js").SelectItems;
+export type GetItemsFetch = import("./types.js").GetItemsFetch;
+export type Child = import("./types.js").Child;
+export type Children = import("./types.js").Children;
+export type ChildSlot = import("./types.js").ChildSlot;
+export type CompositeCompObject = import("./types.js").CompositeCompObject;
+export type SlotCompObject = import("./types.js").SlotCompObject;
+export type ItemsBasedCompObject = import("./types.js").ItemsBasedCompObject;
+export type FocusableCompObject = import("./types.js").FocusableCompObject;
+export type GetItems = import("./types.js").GetItems;
+export type Expression = import("./types.js").Expression;
+export type Cols = import("./types.js").Cols;
+export type ColsObj = import("./types.js").ColsObj;
+export type StateNodeOptionsBase = import("./types.js").StateNodeOptionsBase;
+export type StateNodePropsLib = import("./types.js").StateNodePropsLib;
+export type Slot = import("./types.js").Slot;
+export type Slots = import("./types.js").Slots;
+//# sourceMappingURL=index.d.ts.map

package/types/normalized-layout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/normalized-layout/index.js"],"names":[],"mappings":"AA+BW,uCAAS,gBAAgB,GAAK,MAAM,IAAI,YAAY,CAAA;AAKpD,qCAAS,gBAAgB,GAAK,MAAM,IAAI,cAAc,CAAA;AAKtD,kDAAQ,KAAK,GAAK,KAAK,IAAI,KAAK,GAAG,mBAAmB,CAAA;AAKtD,6CAAQ,KAAK,GAAK,KAAK,IAAI,KAAK,GAAG,cAAc,CAAA;AAKjD,0CAAS,cAAc,cAAc,MAAM,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,aAAa,CAAC,GAAK,MAAM,IAAI,mBAAmB,CAAA;AAK1H,qCAAS,cAAc,GAAK,MAAM,IAAI,OAAO,wBAAwB,EAAE,IAAI,CAAA;AAK3E,0CAAS,cAAc,cAAc,MAAM,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,aAAa,CAAC,GAAK,MAAM,IAAI,mBAAmB,CAAA;AAK1H,sCAAS,cAAc,cAAc,MAAM,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,aAAa,CAAC,GAAK,MAAM,IAAI,oBAAoB,CAAA;AAK3H,+CAAW,QAAQ,GAAK,QAAQ,IAAI,UAAU,CAAA;AAK9C,0CAAW,QAAQ,GAAK,QAAQ,IAAI,aAAa,CAAA;AAKjD,iCAAO,IAAI,GAAK,IAAI,IAAI;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAA;AAMtC,qCAAO,IAAI,GAAK,IAAI,IAAI;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAA;AAM1C,iCAAO,IAAI,GAAK,IAAI,IAAI;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAA;AA1FjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,uCAAwB,OAAO,aAAa,EAAE,wBAAwB,CAA8E;AAEpJ,qCAAiD,GAAG,CAAa;+BAzBpD,OAAO,YAAY,EAAE,gBAAgB;2BACrC,OAAO,YAAY,EAAE,YAAY;6BACjC,OAAO,YAAY,EAAE,cAAc;yBACnC,OAAO,YAAY,EAAE,UAAU;0BAC/B,OAAO,YAAY,EAAE,WAAW;4BAChC,OAAO,YAAY,EAAE,aAAa;oBAClC,OAAO,YAAY,EAAE,KAAK;uBAC1B,OAAO,YAAY,EAAE,QAAQ;wBAC7B,OAAO,YAAY,EAAE,SAAS;kCAC9B,OAAO,YAAY,EAAE,mBAAmB;6BACxC,OAAO,YAAY,EAAE,cAAc;mCACnC,OAAO,YAAY,EAAE,oBAAoB;kCACzC,OAAO,YAAY,EAAE,mBAAmB;uBACxC,OAAO,YAAY,EAAE,QAAQ;yBAC7B,OAAO,YAAY,EAAE,UAAU;mBAC/B,OAAO,YAAY,EAAE,IAAI;sBACzB,OAAO,YAAY,EAAE,OAAO;mCAC5B,OAAO,YAAY,EAAE,oBAAoB;gCACzC,OAAO,YAAY,EAAE,iBAAiB;mBACtC,OAAO,YAAY,EAAE,IAAI;oBACzB,OAAO,YAAY,EAAE,KAAK"}

package/types/normalized-layout/schema.d.ts

@@ -0,0 +1,583 @@
+declare namespace _default {
+    let $id: string;
+    let $defs: {
+        "normalized-layout": {
+            title: string;
+            type: string;
+            unevaluatedProperties: boolean;
+            oneOf: {
+                $ref: string;
+            }[];
+        };
+        "switch-struct": {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                switch: {
+                    type: string;
+                    items: {
+                        $ref: string;
+                    };
+                };
+            };
+        };
+        "base-comp-object": {
+            type: string;
+            required: string[];
+            properties: {
+                comp: {
+                    type: string;
+                };
+                if: {
+                    $ref: string;
+                };
+                options: {
+                    $ref: string;
+                };
+                getOptions: {
+                    $ref: string;
+                };
+                defaultData: {};
+                getDefaultData: {
+                    $ref: string;
+                };
+                constData: {};
+                getConstData: {
+                    $ref: string;
+                };
+                transformData: {
+                    $ref: string;
+                };
+                nullable: {
+                    type: string;
+                };
+                help: {
+                    type: string;
+                };
+                cols: {
+                    $ref: string;
+                };
+                props: {
+                    $ref: string;
+                };
+                getProps: {
+                    $ref: string;
+                };
+                slots: {
+                    $ref: string;
+                };
+            };
+        };
+        "composite-comp-object": {
+            allOf: ({
+                $ref: string;
+                type?: undefined;
+                required?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    comp: {
+                        type: string;
+                    };
+                    title: {
+                        type: string[];
+                    };
+                    subtitle: {
+                        type: string[];
+                    };
+                    children: {
+                        $ref: string;
+                    };
+                };
+                $ref?: undefined;
+            })[];
+        };
+        "slot-comp-object": {
+            allOf: ({
+                $ref: string;
+                type?: undefined;
+                required?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    comp: {
+                        type: string;
+                        const: string;
+                    };
+                };
+                $ref?: undefined;
+            })[];
+        };
+        "simple-comp-object": {
+            allOf: ({
+                $ref: string;
+                type?: undefined;
+                required?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    comp: {
+                        type: string;
+                    };
+                    label: {
+                        type: string;
+                    };
+                    hint: {
+                        type: string[];
+                    };
+                };
+                $ref?: undefined;
+            })[];
+        };
+        "focusable-comp-object": {
+            allOf: ({
+                $ref: string;
+                type?: undefined;
+                required?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    comp: {
+                        type: string;
+                    };
+                    autofocus: {
+                        type: string;
+                    };
+                };
+                $ref?: undefined;
+            })[];
+        };
+        "items-based-comp-object": {
+            allOf: ({
+                $ref: string;
+                type?: undefined;
+                required?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    comp: {
+                        type: string;
+                    };
+                    items: {
+                        $ref: string;
+                    };
+                    getItems: {
+                        $ref: string;
+                    };
+                };
+                $ref?: undefined;
+            })[];
+        };
+        "multiple-compat-comp-object": {
+            allOf: ({
+                $ref: string;
+                type?: undefined;
+                required?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                properties: {
+                    comp: {
+                        type: string;
+                    };
+                    multiple: {
+                        type: string;
+                    };
+                    separator: {
+                        type: string;
+                    };
+                };
+                $ref?: undefined;
+            })[];
+        };
+        "child-ref": {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                key: {
+                    type: string[];
+                };
+                cols: {
+                    $ref: string;
+                };
+                if: {
+                    $ref: string;
+                };
+                slots: {
+                    $ref: string;
+                };
+            };
+        };
+        "child-composite": {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                key: {
+                    type: string[];
+                };
+                cols: {
+                    $ref: string;
+                };
+                comp: {
+                    type: string;
+                };
+                title: {
+                    type: string;
+                };
+                subtitle: {
+                    type: string;
+                };
+                children: {
+                    $ref: string;
+                };
+                if: {
+                    $ref: string;
+                };
+                slots: {
+                    $ref: string;
+                };
+            };
+        };
+        "child-slot": {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                key: {
+                    type: string[];
+                };
+                cols: {
+                    $ref: string;
+                };
+                comp: {
+                    const: string;
+                };
+                if: {
+                    $ref: string;
+                };
+                slots: {
+                    $ref: string;
+                };
+            };
+        };
+        child: {
+            title: string;
+            type: string;
+            oneOf: {
+                $ref: string;
+            }[];
+        };
+        children: {
+            type: string;
+            items: {
+                $ref: string;
+            };
+        };
+        "select-items": {
+            type: string;
+            items: {
+                $ref: string;
+            };
+        };
+        "select-item": {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                };
+                key: {
+                    type: string;
+                };
+                value: {};
+                icon: {
+                    type: string;
+                };
+            };
+        };
+        "get-items": {
+            type: string;
+            allOf: ({
+                properties: {
+                    returnObjects: {
+                        type: string;
+                        readOnly: boolean;
+                    };
+                    itemsResults: {
+                        $ref: string;
+                    };
+                    itemTitle: {
+                        $ref: string;
+                    };
+                    itemKey: {
+                        $ref: string;
+                    };
+                    itemValue: {
+                        $ref: string;
+                    };
+                    itemIcon: {
+                        $ref: string;
+                    };
+                    immutable: {
+                        type: string;
+                    };
+                };
+                oneOf?: undefined;
+            } | {
+                oneOf: {
+                    $ref: string;
+                }[];
+                properties?: undefined;
+            })[];
+        };
+        "get-items-fetch": {
+            type: string;
+            required: string[];
+            properties: {
+                url: {
+                    $ref: string;
+                };
+                qSearchParam: {
+                    type: string;
+                };
+                searchParams: {
+                    type: string;
+                    patternProperties: {
+                        ".*": {
+                            $ref: string;
+                        };
+                    };
+                };
+            };
+        };
+        expression: {
+            type: string;
+            required: string[];
+            properties: {
+                type: {
+                    type: string;
+                    enum: string[];
+                };
+                expr: {
+                    type: string;
+                };
+                pure: {
+                    type: string;
+                };
+                dataAlias: {
+                    type: string;
+                };
+                ref: {
+                    type: string;
+                    readOnly: boolean;
+                };
+            };
+        };
+        "cols-obj": {
+            type: string;
+            additionalProperties: boolean;
+            required: string[];
+            properties: {
+                xs: {
+                    $ref: string;
+                    default: number;
+                };
+                sm: {
+                    $ref: string;
+                };
+                md: {
+                    $ref: string;
+                };
+                lg: {
+                    $ref: string;
+                };
+                xl: {
+                    $ref: string;
+                };
+                xxl: {
+                    $ref: string;
+                };
+            };
+        };
+        cols: {
+            type: string;
+            minimum: number;
+            maximum: number;
+        };
+        slot: {
+            oneOf: ({
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    text: {
+                        type: string;
+                    };
+                    markdown?: undefined;
+                    name?: undefined;
+                    props?: undefined;
+                };
+            } | {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    markdown: {
+                        type: string;
+                    };
+                    text?: undefined;
+                    name?: undefined;
+                    props?: undefined;
+                };
+            } | {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    props: {
+                        type: string;
+                    };
+                    text?: undefined;
+                    markdown?: undefined;
+                };
+            })[];
+        };
+        slots: {
+            type: string;
+            allOf: ({
+                $ref: string;
+                properties?: undefined;
+            } | {
+                properties: {
+                    before: {
+                        $ref: string;
+                    };
+                    after: {
+                        $ref: string;
+                    };
+                    component: {
+                        $ref: string;
+                    };
+                };
+                $ref?: undefined;
+            })[];
+        };
+        "state-node-options-base": {
+            type: string;
+            allOf: ({
+                $ref: string;
+                properties?: undefined;
+            } | {
+                properties: {
+                    readOnly: {
+                        type: string;
+                        default: boolean;
+                    };
+                    summary: {
+                        type: string;
+                        default: boolean;
+                    };
+                    titleDepth: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                        default: number;
+                    };
+                    density: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    indent: {
+                        type: string[];
+                    };
+                    removeAdditional: {
+                        description: string;
+                        default: string;
+                        oneOf: ({
+                            type: string;
+                            enum?: undefined;
+                        } | {
+                            type: string;
+                            enum: string[];
+                        })[];
+                    };
+                    validateOn: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    updateOn: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    debounceInputMs: {
+                        type: string;
+                        minimum: number;
+                        default: number;
+                    };
+                    initialValidation: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    defaultOn: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    autofocus: {
+                        type: string;
+                        default: boolean;
+                    };
+                    readOnlyPropertiesMode: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                };
+                $ref?: undefined;
+            })[];
+        };
+        "state-node-options-base-lib": {
+            type: string;
+            patternProperties: {
+                ".*": {};
+            };
+        };
+        "state-node-props-lib": {
+            type: string;
+            patternProperties: {
+                ".*": {};
+            };
+        };
+        "state-node-slots-lib": {
+            type: string;
+            patternProperties: {
+                ".*": {
+                    $ref: string;
+                };
+            };
+        };
+    };
+}
+export default _default;
+//# sourceMappingURL=schema.d.ts.map

package/types/normalized-layout/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/normalized-layout/schema.js"],"names":[],"mappings":""}