@ghentcdh/json-forms-core 0.0.1

package/lib/filter.d.ts

@@ -0,0 +1,13 @@
+import { SortDir } from './request.model';
+export declare const Operator: readonly ["contains", "equals"];
+export type OperatorType = (typeof Operator)[number];
+export type Filter = {
+    key: string;
+    value: any;
+    operator: OperatorType;
+    label?: string;
+};
+export declare const buildSort: (key: string, sortDir: SortDir) => any;
+export declare const buildSortKey: (keys: string[], sortDir: any) => any;
+export declare const buildFilter: (filters: string[]) => Record<string, any>;
+export declare const extractFilters: (filters: string[]) => Filter[];

package/lib/layout/builder.d.ts

@@ -0,0 +1,12 @@
+import { ElementBuilder } from './layout.builder';
+export declare abstract class Builder<TYPE> {
+    protected readonly type: string;
+    constructor(type: string);
+    abstract build(): TYPE;
+}
+export declare abstract class BuilderWithElements<TYPE, CONTROL_TYPE> extends Builder<TYPE> {
+    protected elements: Array<ElementBuilder<CONTROL_TYPE>>;
+    addControl(control: ElementBuilder<CONTROL_TYPE>): this;
+    addControls(...controls: Array<ElementBuilder<CONTROL_TYPE>>): this;
+    protected buildElements(): (import('./control.builder').ControlTypes | import('./layout.builder').LayoutType | import('./category.builder').CategoryType<CONTROL_TYPE> | import('./group.builder').GroupType<CONTROL_TYPE> | import('../..').TextCellType)[];
+}

package/lib/layout/category.builder.d.ts

@@ -0,0 +1,20 @@
+import { BuilderWithElements } from './builder';
+import { ElementBuilder } from './layout.builder';
+type Rule = {
+    effect: 'SHOW';
+    condition: any;
+};
+export type CategoryType<TYPE> = {
+    type: 'Category';
+    label: string;
+    elements?: ElementBuilder<TYPE>[];
+    rule?: Rule;
+};
+export declare class CategoryBuilder<TYPE> extends BuilderWithElements<CategoryType<TYPE>, TYPE> {
+    private readonly label;
+    private rule;
+    private constructor();
+    static label(label: string): CategoryBuilder<unknown>;
+    build(): CategoryType<TYPE>;
+}
+export {};

package/lib/layout/control.builder.d.ts

@@ -0,0 +1,67 @@
+import { Builder } from './builder';
+import { LayoutBuilder } from './layout.builder';
+export declare const ControlType: {
+    readonly number: "number";
+    readonly string: "string";
+    readonly integer: "Integer";
+    readonly autocomplete: "autocomplete";
+    readonly textArea: "textArea";
+    readonly markdown: "markdown";
+    readonly fixedArray: "fixedArray";
+    readonly array: "array";
+    readonly custom: "custom";
+};
+export interface TextAreaOptions extends ControlOption {
+    format: 'textArea';
+}
+export interface DetailOptions extends ControlOption {
+    format: 'fixedArray';
+}
+export interface AutocompleteOptions extends ControlOption {
+    format: 'autocomplete';
+    uri: string;
+    dataField?: string;
+    field: {
+        id: string;
+        label: string;
+    };
+}
+export type ArrayActionType = 'edit';
+export type ArrayAction = {
+    type: ArrayActionType;
+    idField: string;
+};
+export interface ControlOption {
+    format?: string;
+    readonly?: boolean;
+    label?: string;
+    styles?: Partial<any>;
+    elements?: any;
+    elementLabelProp?: string;
+    labelKey?: string;
+    actions?: ArrayAction[];
+}
+export type ControlTypes = {
+    type: 'Control' | 'Object' | 'TextCell';
+    scope: string;
+    options?: TextAreaOptions | AutocompleteOptions | DetailOptions;
+};
+export declare class ControlBuilder<TYPE, KEY = keyof TYPE> extends Builder<ControlTypes> {
+    private readonly scope;
+    private options;
+    private _detail?;
+    private constructor();
+    static asObject<TYPE>(property: keyof TYPE): ControlBuilder<TYPE>;
+    static properties<TYPE>(property: keyof TYPE): ControlBuilder<TYPE>;
+    static asCustom<TYPE>(property: keyof TYPE, type: string): ControlBuilder<TYPE>;
+    detail<TYPE>(layoutBuilder: LayoutBuilder<TYPE>, label?: string): this;
+    addAction(action: ArrayAction): this;
+    detailFixed<TYPE>(layoutBuilder: LayoutBuilder<TYPE>, label?: string): this;
+    labelKey(labelKey: string): this;
+    readonly(): ControlBuilder<TYPE>;
+    markdown(): ControlBuilder<TYPE>;
+    textArea(options?: Omit<TextAreaOptions, 'format'>): this;
+    autocomplete(options: Omit<AutocompleteOptions, 'format'>): this;
+    width(width: 'xs' | 'sm' | 'md' | 'lg' | 'xl'): this;
+    build(): ControlTypes;
+}

package/lib/layout/group.builder.d.ts

@@ -0,0 +1,13 @@
+import { BuilderWithElements } from './builder';
+import { ElementBuilder } from './layout.builder';
+export type GroupType<TYPE> = {
+    type: 'Group';
+    label: string;
+    elements?: ElementBuilder<TYPE>[];
+};
+export declare class GroupBuilder<TYPE> extends BuilderWithElements<GroupType<TYPE>, TYPE> {
+    private readonly label;
+    private constructor();
+    static label(label: string): GroupBuilder<unknown>;
+    build(): GroupType<TYPE>;
+}

package/lib/layout/layout.builder.d.ts

@@ -0,0 +1,19 @@
+import { BuilderWithElements } from './builder';
+import { CategoryBuilder } from './category.builder';
+import { ControlBuilder, ControlTypes } from './control.builder';
+import { GroupBuilder } from './group.builder';
+import { TextCellBuilder } from '../table/builder';
+export type ElementBuilder<TYPE> = ControlBuilder<TYPE> | LayoutBuilder<TYPE> | CategoryBuilder<TYPE> | GroupBuilder<TYPE> | TextCellBuilder<TYPE>;
+export type LayoutType = {
+    type: 'HorizontalLayout' | 'VerticalLayout';
+    elements: Array<ControlTypes | LayoutType>;
+};
+export declare class LayoutBuilder<TYPE> extends BuilderWithElements<LayoutType, TYPE> {
+    private options;
+    protected constructor(type: 'HorizontalLayout' | 'VerticalLayout' | 'Categorization' | 'table', options?: {});
+    static horizontal<TYPE>(): LayoutBuilder<TYPE>;
+    static stepper(hideNavButtons?: boolean): LayoutBuilder<unknown>;
+    static table(): LayoutBuilder<unknown>;
+    static vertical<TYPE>(): LayoutBuilder<TYPE>;
+    build(): LayoutType;
+}

package/lib/request.model.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export declare const SortDirEnum: z.ZodEnum<["asc", "desc"]>;
+export type SortDir = z.infer<typeof SortDirEnum>;
+export declare const RequestSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sort: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    sortDir: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+    filter: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>>;
+}, "strip", z.ZodTypeAny, {
+    sort: string;
+    filter: string[];
+    page: number;
+    pageSize: number;
+    sortDir: "asc" | "desc";
+}, {
+    sort?: string | undefined;
+    filter?: string | string[] | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortDir?: "asc" | "desc" | undefined;
+}>;
+export type Request = z.infer<typeof RequestSchema>;
+export declare const RequestSchemaWithOffset: z.ZodEffects<z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sort: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    sortDir: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+    filter: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>>;
+}, "strip", z.ZodTypeAny, {
+    sort: string;
+    filter: string[];
+    page: number;
+    pageSize: number;
+    sortDir: "asc" | "desc";
+}, {
+    sort?: string | undefined;
+    filter?: string | string[] | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortDir?: "asc" | "desc" | undefined;
+}>, {
+    sort: string;
+    offset: number;
+    filter: string[];
+    page: number;
+    pageSize: number;
+    sortDir: "asc" | "desc";
+}, {
+    sort?: string | undefined;
+    filter?: string | string[] | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortDir?: "asc" | "desc" | undefined;
+}>;

package/lib/response.model.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export declare const ResponseRequestSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sort: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    sortDir: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+    filter: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>>;
+} & {
+    count: z.ZodNumber;
+    totalPages: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    sort: string;
+    filter: string[];
+    page: number;
+    pageSize: number;
+    sortDir: "asc" | "desc";
+    count: number;
+    totalPages: number;
+}, {
+    count: number;
+    totalPages: number;
+    sort?: string | undefined;
+    filter?: string | string[] | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortDir?: "asc" | "desc" | undefined;
+}>;
+export declare const ResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodUnknown, "many">;
+    request: z.ZodObject<{
+        page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        sort: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        sortDir: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+        filter: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>>>;
+    } & {
+        count: z.ZodNumber;
+        totalPages: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        sort: string;
+        filter: string[];
+        page: number;
+        pageSize: number;
+        sortDir: "asc" | "desc";
+        count: number;
+        totalPages: number;
+    }, {
+        count: number;
+        totalPages: number;
+        sort?: string | undefined;
+        filter?: string | string[] | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        sortDir?: "asc" | "desc" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    data: unknown[];
+    request: {
+        sort: string;
+        filter: string[];
+        page: number;
+        pageSize: number;
+        sortDir: "asc" | "desc";
+        count: number;
+        totalPages: number;
+    };
+}, {
+    data: unknown[];
+    request: {
+        count: number;
+        totalPages: number;
+        sort?: string | undefined;
+        filter?: string | string[] | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        sortDir?: "asc" | "desc" | undefined;
+    };
+}>;
+export type ResponseData<TYPE> = z.infer<typeof ResponseSchema> & {
+    data: TYPE[];
+};

package/lib/schema.model.d.ts

@@ -0,0 +1,44 @@
+import { JsonSchema } from '@jsonforms/core';
+import { Layout } from '@jsonforms/core/src/models/uischema';
+import { ZodObject } from 'zod';
+export declare enum Size {
+    xs = "xs",
+    sm = "sm",
+    lg = "lg",
+    xl = "xl"
+}
+export type JsonFormsLayout = {
+    uiSchema: Layout;
+    schema: JsonSchema;
+    modalSize?: Size;
+};
+export type FormSchemaModel = {
+    form: JsonFormsLayout;
+    table?: JsonFormsLayout;
+    filter?: JsonFormsLayout;
+    uri: string;
+    searchUri: string;
+};
+export declare const createSchema: (props: {
+    uiSchema: any;
+    jsonSchema: JsonSchema;
+    tableSchema?: JsonSchema;
+    filterSchema?: JsonSchema;
+    dtoSchema: ZodObject<any>;
+    responseSchema?: ZodObject<any>;
+    uri: string;
+    searchUri?: string;
+    modalSize?: Size;
+}) => {
+    dtoSchema: ZodObject<any, import('zod').UnknownKeysParam, import('zod').ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>;
+    responseSchema: ZodObject<any, import('zod').UnknownKeysParam, import('zod').ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>;
+    schema: FormSchemaModel;
+};

package/lib/schema.utils.d.ts

@@ -0,0 +1,12 @@
+import { JsonSchema } from '@jsonforms/core';
+type Field = {
+    scope: string;
+};
+export declare const findProperty: <F extends Field>(column: F, schema: JsonSchema) => {
+    id: string;
+    property: any;
+} | {
+    id: null;
+    property: null;
+};
+export {};

package/lib/table/builder.d.ts

@@ -0,0 +1,31 @@
+import { Builder } from '../layout/builder';
+export interface TextCellOption {
+    format: 'TextCell';
+    sortId?: string;
+}
+export interface KeyValueOption extends Omit<TextCellOption, 'format'> {
+    format: 'keyValue';
+    key: string;
+}
+export type TextCellType = {
+    type: 'TextCell';
+    scope: string;
+    options?: KeyValueOption;
+};
+export declare class TextCellBuilder<TYPE> extends Builder<TextCellType> {
+    private readonly scope;
+    private options;
+    private constructor();
+    static properties<TYPE>(property: keyof TYPE): TextCellBuilder<TYPE>;
+    key(key: string): TextCellBuilder<TYPE>;
+    setSortId(sortId: string): TextCellBuilder<TYPE>;
+    build(): TextCellType;
+}
+export declare class TableBuilder<TYPE> {
+    private builder;
+    private constructor();
+    static init<TYPE>(): TableBuilder<TYPE>;
+    addControl(control: TextCellBuilder<TYPE>): this;
+    addControls(...controls: Array<TextCellBuilder<TYPE>>): this;
+    build(): import('../layout/layout.builder').LayoutType;
+}

package/lib/table/utils.d.ts

@@ -0,0 +1,7 @@
+import { JsonSchema } from '@jsonforms/core';
+import { TextCellType } from './builder';
+export type ColumnDef = TextCellType & {
+    id: string;
+    label: string;
+};
+export declare const findColumnDef: (column: TextCellType, schema: JsonSchema) => TextCellType;

package/lib/zod.types.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const PositiveRequestNumber: () => z.ZodNumber;
+export declare const StringOrArray: () => z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, string[], string | string[]>;

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@ghentcdh/json-forms-core",
+  "version": "0.0.1",
+  "dependencies": {
+    "zod": "^3.24.1",
+    "@anatine/zod-openapi": "^2.2.6",
+    "@jsonforms/core": "^3.4.1",
+    "lodash-es": "^4.17.21"
+  },
+  "type": "module",
+  "main": "./index.js",
+  "typings": "./index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GhentCDH/ghentcdh-monorepo.git"
+  }
+}