@amodx/schemas 0.0.1

package/Schemas/ObjectSchema.js

@@ -0,0 +1,103 @@
+import { SchemaNode } from "./SchemaNode";
+import { Property } from "../Properties/Property";
+export class ObjectSchema {
+    __schema;
+    __root = new SchemaNode(Property.Create({ id: "__root__" }), {});
+    constructor(__schema) {
+        this.__schema = __schema;
+    }
+    init() {
+        this.traverse((_) => {
+            _.property.initialize && _.property.initialize(_);
+            _.init(this);
+        });
+        this.evaluate();
+        this.validate();
+        return this;
+    }
+    evaluate() {
+        this.traverse((_) => {
+            _.observers.evaluate.notify();
+        });
+    }
+    validate() {
+        this.traverse((_) => {
+            _.observers.evaluate.notify();
+        });
+    }
+    traverse(run) {
+        const traverse = (parent) => {
+            if (!parent.children)
+                return;
+            for (const node of parent.children) {
+                run(node);
+                if (node.property.children && node.property.children.length) {
+                    traverse(node);
+                }
+            }
+        };
+        traverse(this.__root);
+    }
+    getRoot() {
+        return this.__root;
+    }
+    clone() {
+        return this.__schema
+            .instantiate()
+            .getSchema();
+    }
+    getNode(path) {
+        let finalNode = null;
+        const traverse = (node, path) => {
+            if (!node.children)
+                return;
+            for (const child of node.children) {
+                if (child.property.id == path[0]) {
+                    if (child.property.children && child.property.children.length) {
+                        path.shift();
+                        traverse(child, path);
+                        return;
+                    }
+                    finalNode = child;
+                }
+            }
+        };
+        traverse(this.getRoot(), [...path.path]);
+        return finalNode;
+    }
+    store() {
+        const rootObject = {};
+        const traverse = (schemaNode, parentObject) => {
+            if (!schemaNode.children)
+                return;
+            for (const node of schemaNode.children) {
+                if (node.children && node.children.length) {
+                    const parent = {};
+                    traverse(node, parent);
+                    parentObject[node.property.id] = parent;
+                    continue;
+                }
+                parentObject[node.property.id] = node.store();
+            }
+        };
+        traverse(this.getRoot(), rootObject);
+        return rootObject;
+    }
+    loadIn(data) {
+        const traverse = (schemaNode, parentObject) => {
+            if (!schemaNode.children)
+                return;
+            for (const node of schemaNode.children) {
+                if (node.property.id in parentObject) {
+                    if (node.children && node.children.length) {
+                        traverse(node, parentObject[node.property.id]);
+                    }
+                    else {
+                        node.loadIn(parentObject[node.property.id]);
+                    }
+                }
+            }
+        };
+        traverse(this.getRoot(), data);
+    }
+}

package/Schemas/ObjectSchemaInstance.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from "../Schema";
+import { ObjectSchema } from "./ObjectSchema";
+export declare class ObjectSchemaInstanceBase {
+    private readonly __schema;
+    private readonly __objectSchema;
+    constructor(__schema: Schema, __objectSchema: ObjectSchema);
+    getSchema(): ObjectSchema<{}>;
+    toJSON(): {};
+}
+export type ObjectSchemaInstance<T extends object = {}> = ObjectSchemaInstanceBase & T;

package/Schemas/ObjectSchemaInstance.js

@@ -0,0 +1,14 @@
+export class ObjectSchemaInstanceBase {
+    __schema;
+    __objectSchema;
+    constructor(__schema, __objectSchema) {
+        this.__schema = __schema;
+        this.__objectSchema = __objectSchema;
+    }
+    getSchema() {
+        return this.__objectSchema;
+    }
+    toJSON() {
+        return this.__objectSchema.store();
+    }
+}

package/Schemas/SchemaNode.d.ts

@@ -0,0 +1,62 @@
+import { Property } from "../Properties/Property";
+import { PropertyInputBase } from "../Inputs/PropertyInput";
+import { Observable } from "@amodx/core/Observers/index";
+import { Pipeline } from "@amodx/core/Pipelines";
+import { PropertyConditionAction } from "../Properties/PropertyConditionAction";
+import { ObjectSchema } from "./ObjectSchema";
+import { ObjectPropertyValidatorResponse } from "../Validation";
+export declare class TemplateNode {
+    property: Property;
+    constructor(property: Property);
+    children: TemplateNode[];
+}
+declare class SchemaNodeObservers<Value = any, Input extends PropertyInputBase<any, any> = any> {
+    stateUpdated: Observable<SchemaNode<Value, Input>>;
+    updated: Observable<SchemaNode<Value, Input>>;
+    loadedIn: Observable<SchemaNode<Value, Input>>;
+    updatedOrLoadedIn: Observable<SchemaNode<Value, Input>>;
+    evaluate: Observable<void>;
+    validate: Observable<void>;
+}
+declare class SchemaNodePipelines<Value = any, Input extends PropertyInputBase<any, any> = any> {
+    onStore: Pipeline<Property<Value, Input["data"]>>;
+    updated: Pipeline<{
+        newValue: any;
+        node: SchemaNode<Value, Input>;
+    }>;
+    loadedIn: Pipeline<{
+        value: any;
+        node: SchemaNode<Value, Input>;
+    }>;
+}
+export declare class SchemaNode<Value = any, Input extends PropertyInputBase<any, any> = any> {
+    property: Property<Value, Input["data"]>;
+    root: any;
+    children: SchemaNode[] | null;
+    conditions: PropertyConditionAction[];
+    input: Input | null;
+    observers: SchemaNodeObservers<Value, Input>;
+    pipelines: SchemaNodePipelines<Value, Input>;
+    validatorResponse: ObjectPropertyValidatorResponse;
+    constructor(property: Property<Value, Input["data"]>, root: any);
+    private proxy;
+    enableProxy(get: () => Value, set: (value: Value) => Value): void;
+    disableProxy(): void;
+    private getValue;
+    private setValue;
+    init(schema: ObjectSchema): void;
+    evaluateConditions(): void;
+    validate(): void;
+    isValid(): boolean;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    isLocked(): boolean;
+    setLocked(locked: boolean): void;
+    store(): Value;
+    loadIn(value: any): void;
+    get(): Value;
+    update(newValue: any): void;
+    forEach(run: (node: SchemaNode) => void): void;
+    map<T>(map: (node: SchemaNode) => T): T[];
+}
+export {};

package/Schemas/SchemaNode.js

@@ -0,0 +1,172 @@
+import { Property } from "../Properties/Property";
+import { PropertyInputRegister } from "../Inputs/PropertyInputRegister";
+import { Observable } from "@amodx/core/Observers/index";
+import { Pipeline } from "@amodx/core/Pipelines";
+import { ObjectPropertyValidatorRegister, } from "../Validation";
+export class TemplateNode {
+    property;
+    constructor(property) {
+        this.property = property;
+    }
+    children;
+}
+class SchemaNodeObservers {
+    stateUpdated = new Observable();
+    updated = new Observable();
+    loadedIn = new Observable();
+    updatedOrLoadedIn = new Observable();
+    evaluate = new Observable();
+    validate = new Observable();
+}
+class SchemaNodePipelines {
+    onStore = new Pipeline();
+    updated = new Pipeline();
+    loadedIn = new Pipeline();
+}
+class SchemaNodeProxy {
+    get;
+    set;
+    constructor(get, set) {
+        this.get = get;
+        this.set = set;
+    }
+}
+export class SchemaNode {
+    property;
+    root;
+    children = null;
+    conditions = [];
+    input;
+    observers = new SchemaNodeObservers();
+    pipelines = new SchemaNodePipelines();
+    validatorResponse;
+    constructor(property, root) {
+        this.property = property;
+        this.root = root;
+        if (property.input) {
+            const inputClass = PropertyInputRegister.getProperty(property.input.type);
+            this.input = new inputClass(property.input, this);
+        }
+    }
+    proxy = null;
+    enableProxy(get, set) {
+        this.proxy = new SchemaNodeProxy(get, set);
+    }
+    disableProxy() {
+        this.proxy = null;
+    }
+    getValue() {
+        if (!this.proxy)
+            return this.property.value;
+        return this.proxy.get();
+    }
+    setValue(value) {
+        if (!this.proxy)
+            return (this.property.value = value);
+        return this.proxy.set(value);
+    }
+    init(schema) {
+        const property = this.property;
+        if (property.conditions && property.conditions.length) {
+            for (const action of property.conditions) {
+                for (const condition of action.conditions) {
+                    const otherNode = schema.getNode(condition.path);
+                    otherNode.observers.updatedOrLoadedIn.subscribe(this, () => {
+                        action.evaluate(otherNode.get(), this);
+                    });
+                    this.observers.evaluate.subscribe(this, () => {
+                        action.evaluate(otherNode.get(), this);
+                    });
+                }
+                this.conditions.push(action);
+            }
+        }
+        if (property.input?.validator) {
+            const validator = ObjectPropertyValidatorRegister.getValidator(property.input.validator);
+            this.observers.updatedOrLoadedIn.subscribe(this, () => {
+                const response = validator.validate(this.get(), this);
+                this.validatorResponse = response;
+                if (response.success) {
+                    if (!property.state.valid) {
+                        property.state.valid = true;
+                        this.observers.stateUpdated.notify(this);
+                    }
+                }
+                else {
+                    if (property.state.valid) {
+                        property.state.valid = false;
+                        this.observers.stateUpdated.notify(this);
+                    }
+                }
+            });
+        }
+    }
+    evaluateConditions() {
+        this.observers.evaluate.notify();
+    }
+    validate() {
+        this.observers.validate.notify();
+    }
+    isValid() {
+        return this.property.state.valid;
+    }
+    isEnabled() {
+        return this.property.state.enabled;
+    }
+    setEnabled(enabled) {
+        this.property.state.enabled = enabled;
+        this.observers.stateUpdated.notify(this);
+    }
+    isLocked() {
+        return this.property.state.locked;
+    }
+    setLocked(locked) {
+        this.property.state.locked = locked;
+        this.observers.stateUpdated.notify(this);
+    }
+    store() {
+        return this.pipelines.onStore.pipe(Property.Create(this.property)).value;
+    }
+    loadIn(value) {
+        this.setValue(this.pipelines.loadedIn.pipe({
+            node: this,
+            value,
+        }).value);
+        this.observers.loadedIn.notify(this);
+        this.observers.updatedOrLoadedIn.notify(this);
+    }
+    get() {
+        return this.getValue();
+    }
+    update(newValue) {
+        const oldValue = this.getValue();
+        this.setValue(this.pipelines.updated.pipe({
+            node: this,
+            newValue,
+        }).newValue);
+        const newFinalValue = this.getValue();
+        if (this.input) {
+            if (!this.input.compare(oldValue, newFinalValue)) {
+                this.observers.updated.notify(this);
+                this.observers.updatedOrLoadedIn.notify(this);
+            }
+            return;
+        }
+        if (oldValue != newFinalValue) {
+            this.observers.updated.notify(this);
+            this.observers.updatedOrLoadedIn.notify(this);
+        }
+    }
+    forEach(run) {
+        if (!this.children)
+            return;
+        for (const child of this.children) {
+            run(child);
+        }
+    }
+    map(map) {
+        const data = [];
+        this.forEach((_) => data.push(map(_)));
+        return data;
+    }
+}

package/Validation/ObjectPropertyValidator.d.ts

@@ -0,0 +1,7 @@
+import { SchemaNode } from "../Schemas/SchemaNode";
+import type { ObjectPropertyValidatorData, ObjectPropertyValidatorResponse } from "./ObjectValidation.types";
+export declare class ObjectPropertyValidator {
+    data: ObjectPropertyValidatorData;
+    constructor(data: ObjectPropertyValidatorData);
+    validate(value: unknown, data: SchemaNode): ObjectPropertyValidatorResponse;
+}

package/Validation/ObjectPropertyValidator.js

@@ -0,0 +1,9 @@
+export class ObjectPropertyValidator {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    validate(value, data) {
+        return this.data.validate(value, data);
+    }
+}

package/Validation/ObjectPropertyValidatorRegister.d.ts

@@ -0,0 +1,7 @@
+import type { ObjectPropertyValidatorData } from "./ObjectValidation.types.js";
+import { ObjectPropertyValidator } from "./ObjectPropertyValidator.js";
+export declare class ObjectPropertyValidatorRegister {
+    static _validators: Map<string, ObjectPropertyValidator>;
+    static registerValidators(validators: ObjectPropertyValidatorData[]): void;
+    static getValidator(id: string): ObjectPropertyValidator;
+}

package/Validation/ObjectPropertyValidatorRegister.js

@@ -0,0 +1,13 @@
+import { ObjectPropertyValidator } from "./ObjectPropertyValidator.js";
+export class ObjectPropertyValidatorRegister {
+    static _validators = new Map();
+    static registerValidators(validators) {
+        validators.forEach((data) => this._validators.set(data.id, new ObjectPropertyValidator(data)));
+    }
+    static getValidator(id) {
+        const validator = this._validators.get(id);
+        if (!validator)
+            throw new Error(`Validator with ${id} does not exist`);
+        return validator;
+    }
+}

package/Validation/ObjectValidation.types.d.ts

@@ -0,0 +1,13 @@
+import { SchemaNode } from "../Schemas/SchemaNode";
+export type ObjectPropertyValidatorError = {
+    id: string;
+    errorMessage: string;
+};
+export type ObjectPropertyValidatorResponse = {
+    success: boolean;
+    errors?: ObjectPropertyValidatorError[];
+};
+export type ObjectPropertyValidatorData = {
+    id: string;
+    validate(value: unknown, node: SchemaNode): ObjectPropertyValidatorResponse;
+};

package/Validation/ObjectValidation.types.js

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

package/Validation/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ObjectPropertyValidator";
+export * from "./ObjectPropertyValidatorRegister";
+export * from "./ObjectValidation.types";

package/Validation/index.js

@@ -0,0 +1,3 @@
+export * from "./ObjectPropertyValidator";
+export * from "./ObjectPropertyValidatorRegister";
+export * from "./ObjectValidation.types";

package/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./Schema";
+export * from "./Inputs/DefaultInputs";
+export * from "./Properties/Property";
+export * from "./Properties";
+export * from "./Schemas/ObjectSchema";
+export * from "./Schemas/BinaryObjectSchema";
+export * from "./Schemas/ObjectSchemaInstance";
+export * from "./Properties/ObjectPath";

package/index.js

@@ -0,0 +1,8 @@
+export * from "./Schema";
+export * from "./Inputs/DefaultInputs";
+export * from "./Properties/Property";
+export * from "./Properties";
+export * from "./Schemas/ObjectSchema";
+export * from "./Schemas/BinaryObjectSchema";
+export * from "./Schemas/ObjectSchemaInstance";
+export * from "./Properties/ObjectPath";

package/package.json

@@ -0,0 +1,27 @@
+{
+ "name": "@amodx/schemas",
+ "version": "0.0.01",
+ "module": "index.js",
+ "types": "index.d.ts",
+ "type": "module",
+ "description": "Tool for object schemas.",
+ "keywords": [],
+ "scripts": {
+  "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cd ./src && npx tsc",
+  "compile": "cd ./src && npx tsc --watch"
+ },
+ "repository": {
+  "url": "git+https://github.com/Amodx/Libraries.git"
+ },
+ "bugs": {
+  "url": "https://github.com/Amodx/Libraries/issues"
+ },
+ "homepage": "https://github.com/Amodx/Libraries",
+ "author": "Amodx",
+ "license": "MIT",
+ "devDependencies": {},
+ "main": "index.js",
+ "publishConfig": {
+  "access": "public"
+ }
+}