@amodx/schemas 0.0.1

package/Properties/ObjectPath.js

@@ -0,0 +1,33 @@
+export class ObjectPath {
+    path;
+    static Create(path) {
+        return new ObjectPath(path);
+    }
+    static Generator() {
+        return (path) => new ObjectPath(path);
+    }
+    propertyPath;
+    constructor(path) {
+        this.path = path;
+        this.propertyPath = path;
+    }
+    resolvePath(obj) {
+        return this.propertyPath.reduce((acc, part) => acc && acc[part], obj);
+    }
+    resolveParentPath(obj) {
+        return this.propertyPath
+            .slice(0, -1)
+            .reduce((acc, part) => acc && acc[part], obj);
+    }
+    get(obj) {
+        return this.resolvePath(obj);
+    }
+    set(obj, value) {
+        const path = [...this.propertyPath];
+        const lastProperty = path.pop();
+        const target = this.resolveParentPath(obj);
+        if (lastProperty && target) {
+            target[lastProperty] = value;
+        }
+    }
+}

package/Properties/Property.d.ts

@@ -0,0 +1,24 @@
+import { PropertyConditionAction } from "./PropertyConditionAction";
+import { PropertyInputData } from "../Inputs/PropertyInput";
+import { SchemaNode } from "../Schemas/SchemaNode";
+declare class PropertyState {
+    enabled: boolean;
+    locked: boolean;
+    valid: boolean;
+    static Create(data: Partial<PropertyState>): PropertyState;
+    private constructor();
+}
+export declare class Property<Value = any, Input extends PropertyInputData | null = null> {
+    id: string;
+    name: string;
+    value: Value;
+    state: PropertyState;
+    initialize?: ((node: SchemaNode) => void) | undefined;
+    input?: Input | undefined;
+    editable?: boolean | undefined;
+    conditions?: PropertyConditionAction[] | undefined;
+    children?: Property<any>[] | undefined;
+    static Create<Value = any, Input extends PropertyInputData | null = null>(data: Partial<Property<Value, Input>>): Property<Value, Input>;
+    private constructor();
+}
+export {};

package/Properties/Property.js

@@ -0,0 +1,38 @@
+class PropertyState {
+    enabled;
+    locked;
+    valid;
+    static Create(data) {
+        return new PropertyState(data.enabled, data.locked);
+    }
+    constructor(enabled = true, locked = false, valid = true) {
+        this.enabled = enabled;
+        this.locked = locked;
+        this.valid = valid;
+    }
+}
+export class Property {
+    id;
+    name;
+    value;
+    state;
+    initialize;
+    input;
+    editable;
+    conditions;
+    children;
+    static Create(data) {
+        return new Property(data.id ? data.id : "", data.name ? data.name : data.id ? data.id : "", data.value, data.state ? PropertyState.Create(data.state) : PropertyState.Create({}), data.initialize, data.input, data.editable, data.conditions, data.children);
+    }
+    constructor(id, name, value, state, initialize, input, editable, conditions, children) {
+        this.id = id;
+        this.name = name;
+        this.value = value;
+        this.state = state;
+        this.initialize = initialize;
+        this.input = input;
+        this.editable = editable;
+        this.conditions = conditions;
+        this.children = children;
+    }
+}

package/Properties/PropertyCondition.d.ts

@@ -0,0 +1,11 @@
+import { ObjectPath } from "./ObjectPath";
+type LogicalOperation = "==" | "===" | "!=" | "!==" | "<" | ">" | "<=" | ">=";
+export declare class PropertyCondition<Data extends object = {}> {
+    path: ObjectPath<Data, any>;
+    operation: LogicalOperation;
+    static Create<Data extends object>(path: ObjectPath<Data, any>, operation: LogicalOperation, value: any): PropertyCondition<Data>;
+    private constructor();
+    value: any;
+    evaluate(newValue: any): boolean;
+}
+export {};

package/Properties/PropertyCondition.js

@@ -0,0 +1,37 @@
+export class PropertyCondition {
+    path;
+    operation;
+    static Create(path, operation, value) {
+        const query = new PropertyCondition(path, operation);
+        query.value = value;
+        return query;
+    }
+    constructor(path, operation) {
+        this.path = path;
+        this.operation = operation;
+    }
+    value;
+    evaluate(newValue) {
+        const value = this.value;
+        switch (this.operation) {
+            case "==":
+                return newValue == value;
+            case "===":
+                return newValue === value;
+            case "!=":
+                return newValue != value;
+            case "!==":
+                return newValue !== value;
+            case "<":
+                return newValue < value;
+            case ">":
+                return newValue > value;
+            case "<=":
+                return newValue <= value;
+            case ">=":
+                return newValue >= value;
+            default:
+                throw new Error(`Unsupported operation: ${this.operation}`);
+        }
+    }
+}

package/Properties/PropertyConditionAction.d.ts

@@ -0,0 +1,11 @@
+import { SchemaNode } from "../Schemas/SchemaNode";
+import { PropertyCondition } from "./PropertyCondition";
+type PropertyConditionFunction = <Data extends object = {}>(action: PropertyConditionAction<Data>, node: SchemaNode, result: boolean) => void;
+export declare class PropertyConditionAction<Data extends object = {}> {
+    action: "enable" | "lock" | PropertyConditionFunction;
+    conditions: PropertyCondition<Data>[];
+    static Create<Data extends object = any>(action: "enable" | "lock" | PropertyConditionFunction, conditions: PropertyCondition<Data>[]): PropertyConditionAction;
+    private constructor();
+    evaluate(newValue: any, affectedNode: SchemaNode): void;
+}
+export {};

package/Properties/PropertyConditionAction.js

@@ -0,0 +1,38 @@
+export class PropertyConditionAction {
+    action;
+    conditions;
+    static Create(action, conditions) {
+        return new PropertyConditionAction(action, conditions);
+    }
+    constructor(action, conditions) {
+        this.action = action;
+        this.conditions = conditions;
+    }
+    evaluate(newValue, affectedNode) {
+        let result = false;
+        for (const e of this.conditions) {
+            result = e.evaluate(newValue);
+        }
+        if (result) {
+            if (this.action == "enable") {
+                affectedNode.setEnabled(true);
+                return;
+            }
+            if (this.action == "lock") {
+                affectedNode.setLocked(true);
+                return;
+            }
+        }
+        else {
+            if (this.action == "enable") {
+                affectedNode.setEnabled(false);
+                return;
+            }
+            if (this.action == "lock") {
+                affectedNode.setLocked(false);
+                return;
+            }
+        }
+        return this.action(this, affectedNode, result);
+    }
+}

package/Properties.d.ts

@@ -0,0 +1,44 @@
+import { PropertyInputBase, PropertyInputData } from "./Inputs/PropertyInput";
+import { ColorPropertyInput, FilePathPropertyInput, FloatPropertyInput, IntPropertyInput, PasswordPropertyInput, RangePropertyInput, SelectPropertyInput, StringPropertyInput, Vec2PropertyInput, Vec3PropertyInput, CheckboxPropertyInput, DatePropertyInput, TextareaPropertyInput, EmailPropertyInput, UrlPropertyInput } from "./Inputs/DefaultInputs";
+import { ObjectPath } from "./Properties/ObjectPath";
+import { Property } from "./Properties/Property";
+import { PropertyCondition } from "./Properties/PropertyCondition";
+import { PropertyConditionAction } from "./Properties/PropertyConditionAction";
+import { SchemaNode } from "./Schemas/SchemaNode";
+type PropertyCreateData<Value extends any, Input extends PropertyInputData> = {
+    name?: string;
+    value?: Value;
+    validator?: string;
+    initialize?: (node: SchemaNode) => void;
+} & Partial<Input["properties"]>;
+type PropertyFC<Value extends any, Input extends PropertyInputBase> = (id: string, data?: Exclude<PropertyCreateData<Value, Input["data"]>, "id">) => Property<Value, Input["data"]>;
+export declare const PropConditions: ((data: Property<any, any>, ...conditions: PropertyConditionAction[]) => Property<any, any>) & {
+    Action: typeof PropertyConditionAction.Create;
+    Condition: typeof PropertyCondition.Create;
+    Path: typeof ObjectPath.Create;
+};
+export declare const ObjectProp: (id: string, name: string, ...properties: Property<any, any>[]) => Property<any, null>;
+export declare const AnyProp: PropertyFC<any, any>;
+export declare const StringProp: PropertyFC<string, StringPropertyInput>;
+export declare const PasswordProp: PropertyFC<string, PasswordPropertyInput>;
+export declare const FloatProp: PropertyFC<number, FloatPropertyInput>;
+export declare const IntProp: PropertyFC<number, IntPropertyInput>;
+export declare const RangeProp: PropertyFC<number, RangePropertyInput>;
+export declare const ColorProp: PropertyFC<string, ColorPropertyInput>;
+export declare const SelectProp: PropertyFC<string | number, SelectPropertyInput>;
+export declare const FilePathProp: PropertyFC<string, FilePathPropertyInput>;
+export declare const Vec2Prop: PropertyFC<{
+    x: number;
+    y: number;
+}, Vec2PropertyInput>;
+export declare const Vec3Prop: PropertyFC<{
+    x: number;
+    y: number;
+    z: number;
+}, Vec3PropertyInput>;
+export declare const CheckboxProp: PropertyFC<boolean, CheckboxPropertyInput>;
+export declare const DateProp: PropertyFC<string, DatePropertyInput>;
+export declare const TextareaProp: PropertyFC<string, TextareaPropertyInput>;
+export declare const EmailProp: PropertyFC<string, EmailPropertyInput>;
+export declare const UrlProp: PropertyFC<string, UrlPropertyInput>;
+export {};

package/Properties.js

@@ -0,0 +1,239 @@
+import { ColorPropertyInput, FilePathPropertyInput, FloatPropertyInput, IntPropertyInput, PasswordPropertyInput, RangePropertyInput, SelectPropertyInput, StringPropertyInput, Vec2PropertyInput, Vec3PropertyInput, CheckboxPropertyInput, DatePropertyInput, TextareaPropertyInput, EmailPropertyInput, UrlPropertyInput, } from "./Inputs/DefaultInputs";
+import { ObjectPath } from "./Properties/ObjectPath";
+import { Property } from "./Properties/Property";
+import { PropertyCondition } from "./Properties/PropertyCondition";
+import { PropertyConditionAction } from "./Properties/PropertyConditionAction";
+export const PropConditions = Object.assign((data, ...conditions) => {
+    data.conditions = conditions;
+    return data;
+}, {
+    Action: PropertyConditionAction.Create,
+    Condition: PropertyCondition.Create,
+    Path: ObjectPath.Create,
+});
+export const ObjectProp = (id, name, ...properties) => {
+    return Property.Create({
+        id: id,
+        name: name,
+        children: properties,
+    });
+};
+export const AnyProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : null,
+        initialize: data.initialize,
+        input: null,
+    });
+};
+export const StringProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "",
+        initialize: data.initialize,
+        input: StringPropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                min: data.min ? data.min : 0,
+                max: data.max ? data.max : Number.MAX_SAFE_INTEGER,
+            },
+        }),
+    });
+};
+export const PasswordProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "",
+        initialize: data.initialize,
+        input: PasswordPropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                min: data.min ? data.min : 0,
+                max: data.max ? data.max : Number.MAX_SAFE_INTEGER,
+            },
+        }),
+    });
+};
+export const FloatProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : 0,
+        initialize: data.initialize,
+        input: FloatPropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                min: data.min ? data.min : 0,
+                max: data.max ? data.max : Number.MAX_VALUE,
+            },
+        }),
+    });
+};
+export const IntProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : 0,
+        initialize: data.initialize,
+        input: IntPropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                min: data.min ? data.min : 0,
+                max: data.max ? data.max : Number.MAX_SAFE_INTEGER,
+            },
+        }),
+    });
+};
+export const RangeProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : 0,
+        initialize: data.initialize,
+        input: RangePropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                min: data.min ? data.min : 0,
+                max: data.max ? data.max : Number.MAX_VALUE,
+                step: data.step ? data.step : 0.1,
+            },
+        }),
+    });
+};
+export const ColorProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "#ffffff",
+        initialize: data.initialize,
+        input: ColorPropertyInput.Create({
+            validator: data.validator,
+            properties: {},
+        }),
+    });
+};
+export const SelectProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "",
+        initialize: data.initialize,
+        input: SelectPropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                options: data.options ? data.options : [],
+                mode: data.mode,
+            },
+        }),
+    });
+};
+export const FilePathProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "#ffffff",
+        initialize: data.initialize,
+        input: FilePathPropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                acceptedFileExtensions: data.acceptedFileExtensions
+                    ? data.acceptedFileExtensions
+                    : [],
+            },
+        }),
+    });
+};
+export const Vec2Prop = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : { x: 0, y: 0 },
+        initialize: data.initialize,
+        input: Vec2PropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                valueType: data.valueType ? data.valueType : "position",
+            },
+        }),
+    });
+};
+export const Vec3Prop = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : { x: 0, y: 0, z: 0 },
+        initialize: data.initialize,
+        input: Vec3PropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                valueType: data.valueType ? data.valueType : "position",
+            },
+        }),
+    });
+};
+export const CheckboxProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : false,
+        initialize: data.initialize,
+        input: CheckboxPropertyInput.Create({
+            validator: data.validator,
+            properties: {},
+        }),
+    });
+};
+export const DateProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "",
+        initialize: data.initialize,
+        input: DatePropertyInput.Create({
+            validator: data.validator,
+            properties: {},
+        }),
+    });
+};
+export const TextareaProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "",
+        initialize: data.initialize,
+        input: TextareaPropertyInput.Create({
+            validator: data.validator,
+            properties: {
+                rows: data.rows ? data.rows : 4,
+                cols: data.cols ? data.cols : 10,
+            },
+        }),
+    });
+};
+export const EmailProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "",
+        initialize: data.initialize,
+        input: EmailPropertyInput.Create({
+            validator: data.validator,
+            properties: {},
+        }),
+    });
+};
+export const UrlProp = (id, data = {}) => {
+    return Property.Create({
+        id,
+        name: data.name,
+        value: data.value ? data.value : "",
+        initialize: data.initialize,
+        input: UrlPropertyInput.Create({
+            validator: data.validator,
+            properties: {},
+        }),
+    });
+};

package/Schema.d.ts

@@ -0,0 +1,22 @@
+import { Property } from "./Properties/Property";
+import { PropertyInputRegister } from "./Inputs/PropertyInputRegister";
+import { ObjectSchemaInstance } from "./Schemas/ObjectSchemaInstance";
+declare class SchemaData {
+    id: string;
+    name: string;
+    properties: Property<any, any>[];
+    static Create(data: Partial<SchemaData>): SchemaData;
+    private constructor();
+}
+export declare class Schema<DataInterface extends object = {}> {
+    data: SchemaData;
+    static Create<DataInterface extends object = {}>(...properties: Property<any, any>[]): Schema<DataInterface>;
+    static CreateInstance<DataInterface extends object = {}>(...properties: Property<any, any>[]): ObjectSchemaInstance<DataInterface>;
+    static Inputs: typeof PropertyInputRegister;
+    private constructor();
+    private template;
+    createData(): DataInterface;
+    instantiate(data?: Partial<DataInterface>): ObjectSchemaInstance<DataInterface>;
+    private process;
+}
+export {};

package/Schema.js

@@ -0,0 +1,99 @@
+import { Property } from "./Properties/Property";
+import { PropertyInputRegister } from "./Inputs/PropertyInputRegister";
+import { SchemaNode, TemplateNode } from "./Schemas/SchemaNode";
+import { ObjectSchema } from "./Schemas/ObjectSchema";
+import { ObjectSchemaInstanceBase, } from "./Schemas/ObjectSchemaInstance";
+class SchemaData {
+    id;
+    name;
+    properties;
+    static Create(data) {
+        return {
+            id: data.id ? data.id : crypto.randomUUID(),
+            name: data.id ? data.id : data.name || "",
+            properties: data.properties ? [...data.properties] : [],
+        };
+    }
+    constructor(id, name, properties) {
+        this.id = id;
+        this.name = name;
+        this.properties = properties;
+    }
+}
+const traverseInstantiate = (objectSchema, properties, schemaNode, parentObject) => {
+    for (const template of properties.children) {
+        schemaNode.children ??= [];
+        const node = new SchemaNode(Property.Create(template.property), objectSchema);
+        schemaNode.children.push(node);
+        if (template.children && template.children.length) {
+            const parent = {};
+            traverseInstantiate(objectSchema, template, node, parent);
+            parentObject[template.property.id] = parent;
+            continue;
+        }
+        Object.defineProperty(parentObject, template.property.id, {
+            get() {
+                return node.get();
+            },
+            set(value) {
+                node.update(value);
+            },
+        });
+    }
+};
+const traverseCreateData = (properties, parentObject) => {
+    for (const template of properties.children) {
+        if (template.children && template.children.length) {
+            const parent = {};
+            traverseCreateData(template, parent);
+            parentObject[template.property.id] = parent;
+            continue;
+        }
+        Object.defineProperty(parentObject, template.property.id, {
+            value: template.property.value,
+        });
+    }
+};
+export class Schema {
+    data;
+    static Create(...properties) {
+        return new Schema(SchemaData.Create({ id: "", name: "", properties }));
+    }
+    static CreateInstance(...properties) {
+        return new Schema(SchemaData.Create({ id: "", name: "", properties })).instantiate();
+    }
+    static Inputs = PropertyInputRegister;
+    constructor(data) {
+        this.data = data;
+        this.process();
+    }
+    template;
+    createData() {
+        const instance = {};
+        traverseCreateData(this.template, instance);
+        return instance;
+    }
+    instantiate(data) {
+        const objectSchema = new ObjectSchema(this);
+        const instance = new ObjectSchemaInstanceBase(this, objectSchema);
+        traverseInstantiate(objectSchema, this.template, objectSchema.__root, instance);
+        if (data)
+            objectSchema.loadIn(data);
+        objectSchema.init();
+        return instance;
+    }
+    process() {
+        const traverse = (properties, parent) => {
+            for (const property of properties) {
+                parent.children ??= [];
+                const newNode = new TemplateNode(property);
+                parent.children.push(newNode);
+                if (property.children)
+                    traverse(property.children, newNode);
+            }
+        };
+        const root = new TemplateNode(Property.Create({ id: "__root__" }));
+        traverse(this.data.properties, root);
+        this.template = root;
+    }
+}

package/Schemas/BinaryObjectSchema.d.ts

@@ -0,0 +1,3 @@
+import { ObjectSchema } from "./ObjectSchema";
+export declare class BinaryObjectSchema<DataInterface extends object = any> extends ObjectSchema {
+}

package/Schemas/BinaryObjectSchema.js

@@ -0,0 +1,3 @@
+import { ObjectSchema } from "./ObjectSchema";
+export class BinaryObjectSchema extends ObjectSchema {
+}

package/Schemas/ObjectSchema.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from "../Schema";
+import { SchemaNode } from "./SchemaNode";
+import { ObjectPath } from "../Properties/ObjectPath";
+export declare class ObjectSchema<DataInterface extends object = {}> {
+    private readonly __schema;
+    __root: SchemaNode<any, any>;
+    constructor(__schema: Schema);
+    init(): this;
+    evaluate(): void;
+    validate(): void;
+    traverse(run: (node: SchemaNode) => void): void;
+    getRoot(): SchemaNode<any, any>;
+    clone(): ObjectSchema<DataInterface>;
+    getNode(path: ObjectPath<DataInterface, any>): SchemaNode | null;
+    store(): DataInterface;
+    loadIn(data: DataInterface): void;
+}