@amodx/schemas 0.0.1

package/Inputs/DefaultInputs.d.ts

@@ -0,0 +1,201 @@
+import { PropertyInputBase, PropertyInputMetaData } from "./PropertyInput";
+declare class StringInput extends PropertyInputBase<string, {
+    min: number;
+    max: number;
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<StringInput["data"]>): StringInput["data"];
+    compare(value1: string, value2: string): boolean;
+    getClass(): typeof StringInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class ColorInput extends PropertyInputBase<string, {}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<ColorInput["data"]>): ColorInput["data"];
+    compare(value1: string, value2: string): boolean;
+    getClass(): typeof ColorInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class RangeInput extends PropertyInputBase<number, {
+    min: number;
+    max: number;
+    step: number;
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<RangeInput["data"]>): RangeInput["data"];
+    compare(value1: number, value2: number): boolean;
+    getClass(): typeof RangeInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class FloatInput extends PropertyInputBase<number, {
+    min: number;
+    max: number;
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<FloatInput["data"]>): FloatInput["data"];
+    compare(value1: number, value2: number): boolean;
+    getClass(): typeof FloatInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class Vec2Input extends PropertyInputBase<{
+    x: number;
+    y: number;
+}, {
+    valueType: "position" | "dimension";
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<Vec2Input["data"]>): Vec2Input["data"];
+    compare(value1: {
+        x: number;
+        y: number;
+    }, value2: {
+        x: number;
+        y: number;
+    }): boolean;
+    getClass(): typeof Vec2Input;
+    getMeta(): PropertyInputMetaData;
+}
+declare class Vec3Input extends PropertyInputBase<{
+    x: number;
+    y: number;
+    z: number;
+}, {
+    valueType: "position" | "dimension";
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<Vec3Input["data"]>): Vec3Input["data"];
+    compare(value1: {
+        x: number;
+        y: number;
+        z: number;
+    }, value2: {
+        x: number;
+        y: number;
+        z: number;
+    }): boolean;
+    getClass(): typeof Vec3Input;
+    getMeta(): PropertyInputMetaData;
+}
+declare class IntInput extends PropertyInputBase<number, {
+    min: number;
+    max: number;
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<IntInput["data"]>): IntInput["data"];
+    compare(value1: number, value2: number): boolean;
+    getClass(): typeof IntInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class SelectInput extends PropertyInputBase<string | number, {
+    options: string[] | [display: string, value: string | number][];
+    mode?: string;
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<SelectInput["data"]>): SelectInput["data"];
+    compare(value1: string | number, value2: string | number): boolean;
+    getClass(): typeof SelectInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class FilePathInput extends PropertyInputBase<string, {
+    acceptedFileExtensions: string[];
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<FilePathInput["data"]>): FilePathInput["data"];
+    compare(value1: string, value2: string): boolean;
+    getClass(): typeof FilePathInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class PasswordInput extends PropertyInputBase<string, {
+    min: number;
+    max: number;
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<PasswordInput["data"]>): PasswordInput["data"];
+    compare(value1: string, value2: string): boolean;
+    getClass(): typeof PasswordInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class CheckboxInput extends PropertyInputBase<boolean, {}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<CheckboxInput["data"]>): CheckboxInput["data"];
+    compare(value1: boolean, value2: boolean): boolean;
+    getClass(): typeof CheckboxInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class DateInput extends PropertyInputBase<string, {}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<DateInput["data"]>): DateInput["data"];
+    compare(value1: string, value2: string): boolean;
+    getClass(): typeof DateInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class TextareaInput extends PropertyInputBase<string, {
+    rows: number;
+    cols: number;
+}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<TextareaInput["data"]>): TextareaInput["data"];
+    compare(value1: string, value2: string): boolean;
+    getClass(): typeof TextareaInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class EmailInput extends PropertyInputBase<string, {}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<EmailInput["data"]>): EmailInput["data"];
+    compare(value1: string, value2: string): boolean;
+    getClass(): typeof EmailInput;
+    getMeta(): PropertyInputMetaData;
+}
+declare class UrlInput extends PropertyInputBase<string, {}> {
+    static Meta: {
+        id: string;
+        name: string;
+    };
+    static Create(data: Partial<UrlInput["data"]>): UrlInput["data"];
+    compare(value1: string, value2: string): boolean;
+    getClass(): typeof UrlInput;
+    getMeta(): PropertyInputMetaData;
+}
+export { ColorInput as ColorPropertyInput, RangeInput as RangePropertyInput, FloatInput as FloatPropertyInput, Vec2Input as Vec2PropertyInput, Vec3Input as Vec3PropertyInput, IntInput as IntPropertyInput, StringInput as StringPropertyInput, SelectInput as SelectPropertyInput, FilePathInput as FilePathPropertyInput, PasswordInput as PasswordPropertyInput, CheckboxInput as CheckboxPropertyInput, DateInput as DatePropertyInput, TextareaInput as TextareaPropertyInput, EmailInput as EmailPropertyInput, UrlInput as UrlPropertyInput, };

package/Inputs/DefaultInputs.js

@@ -0,0 +1,376 @@
+import { PropertyInputBase } from "./PropertyInput";
+import { PropertyInputRegister } from "./PropertyInputRegister";
+class StringInput extends PropertyInputBase {
+    static Meta = {
+        id: "string",
+        name: "string",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: StringInput.Meta.id,
+            properties: {
+                min: 0,
+                max: Number.MAX_SAFE_INTEGER,
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return StringInput;
+    }
+    getMeta() {
+        return StringInput.Meta;
+    }
+}
+class ColorInput extends PropertyInputBase {
+    static Meta = {
+        id: "color",
+        name: "Color",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: ColorInput.Meta.id,
+            properties: {},
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return ColorInput;
+    }
+    getMeta() {
+        return ColorInput.Meta;
+    }
+}
+class RangeInput extends PropertyInputBase {
+    static Meta = {
+        id: "range",
+        name: "Range",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: RangeInput.Meta.id,
+            properties: {
+                min: 0,
+                max: Number.MAX_SAFE_INTEGER,
+                step: 1,
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return RangeInput;
+    }
+    getMeta() {
+        return RangeInput.Meta;
+    }
+}
+class FloatInput extends PropertyInputBase {
+    static Meta = {
+        id: "float",
+        name: "Float",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: FloatInput.Meta.id,
+            properties: {
+                min: 0,
+                max: Number.MAX_SAFE_INTEGER,
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return FloatInput;
+    }
+    getMeta() {
+        return FloatInput.Meta;
+    }
+}
+class Vec2Input extends PropertyInputBase {
+    static Meta = {
+        id: "vec2",
+        name: "Vec2",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: Vec2Input.Meta.id,
+            properties: {
+                valueType: "position",
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1.x == value2.x && value1.y == value2.y;
+    }
+    getClass() {
+        return Vec2Input;
+    }
+    getMeta() {
+        return Vec2Input.Meta;
+    }
+}
+class Vec3Input extends PropertyInputBase {
+    static Meta = {
+        id: "vec3",
+        name: "Vec3",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: Vec3Input.Meta.id,
+            properties: {
+                valueType: "position",
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1.x == value2.x && value1.y == value2.y && value1.z == value2.z;
+    }
+    getClass() {
+        return Vec3Input;
+    }
+    getMeta() {
+        return Vec3Input.Meta;
+    }
+}
+class IntInput extends PropertyInputBase {
+    static Meta = {
+        id: "int",
+        name: "Int",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: IntInput.Meta.id,
+            properties: {
+                min: 0,
+                max: Number.MAX_SAFE_INTEGER,
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return IntInput;
+    }
+    getMeta() {
+        return IntInput.Meta;
+    }
+}
+class SelectInput extends PropertyInputBase {
+    static Meta = {
+        id: "select",
+        name: "Select",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: SelectInput.Meta.id,
+            properties: {
+                options: [],
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return SelectInput;
+    }
+    getMeta() {
+        return SelectInput.Meta;
+    }
+}
+class FilePathInput extends PropertyInputBase {
+    static Meta = {
+        id: "file-path",
+        name: "File Path",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: FilePathInput.Meta.id,
+            properties: {
+                acceptedFileExtensions: [],
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return FilePathInput;
+    }
+    getMeta() {
+        return FilePathInput.Meta;
+    }
+}
+class PasswordInput extends PropertyInputBase {
+    static Meta = {
+        id: "password",
+        name: "Password",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: PasswordInput.Meta.id,
+            properties: {
+                min: 0,
+                max: Number.MAX_SAFE_INTEGER,
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return PasswordInput;
+    }
+    getMeta() {
+        return PasswordInput.Meta;
+    }
+}
+class CheckboxInput extends PropertyInputBase {
+    static Meta = {
+        id: "checkbox",
+        name: "Checkbox",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: CheckboxInput.Meta.id,
+            properties: {},
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return CheckboxInput;
+    }
+    getMeta() {
+        return CheckboxInput.Meta;
+    }
+}
+class DateInput extends PropertyInputBase {
+    static Meta = {
+        id: "date",
+        name: "Date",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: DateInput.Meta.id,
+            properties: {},
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return DateInput;
+    }
+    getMeta() {
+        return DateInput.Meta;
+    }
+}
+class TextareaInput extends PropertyInputBase {
+    static Meta = {
+        id: "textarea",
+        name: "Textarea",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: TextareaInput.Meta.id,
+            properties: {
+                rows: 4,
+                cols: 50,
+            },
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return TextareaInput;
+    }
+    getMeta() {
+        return TextareaInput.Meta;
+    }
+}
+class EmailInput extends PropertyInputBase {
+    static Meta = {
+        id: "email",
+        name: "Email",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: EmailInput.Meta.id,
+            properties: {},
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return EmailInput;
+    }
+    getMeta() {
+        return EmailInput.Meta;
+    }
+}
+class UrlInput extends PropertyInputBase {
+    static Meta = {
+        id: "url",
+        name: "URL",
+    };
+    static Create(data) {
+        return {
+            ...PropertyInputBase.CreateBase({}),
+            type: UrlInput.Meta.id,
+            properties: {},
+            ...data,
+        };
+    }
+    compare(value1, value2) {
+        return value1 == value2;
+    }
+    getClass() {
+        return UrlInput;
+    }
+    getMeta() {
+        return UrlInput.Meta;
+    }
+}
+PropertyInputRegister.regsiterProperty(ColorInput, RangeInput, FloatInput, Vec2Input, Vec3Input, IntInput, StringInput, SelectInput, FilePathInput, PasswordInput, CheckboxInput, DateInput, TextareaInput, EmailInput, UrlInput);
+export { ColorInput as ColorPropertyInput, RangeInput as RangePropertyInput, FloatInput as FloatPropertyInput, Vec2Input as Vec2PropertyInput, Vec3Input as Vec3PropertyInput, IntInput as IntPropertyInput, StringInput as StringPropertyInput, SelectInput as SelectPropertyInput, FilePathInput as FilePathPropertyInput, PasswordInput as PasswordPropertyInput, CheckboxInput as CheckboxPropertyInput, DateInput as DatePropertyInput, TextareaInput as TextareaPropertyInput, EmailInput as EmailPropertyInput, UrlInput as UrlPropertyInput, };

package/Inputs/PropertyInput.d.ts

@@ -0,0 +1,46 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+import { SchemaNode } from "../Schemas/SchemaNode";
+declare class PropertyInputPipelines<Value = any> {
+    onGet: Pipeline<{
+        value: Value;
+        input: PropertyInputBase;
+    }>;
+    onSet: Pipeline<{
+        newValue: any;
+        input: PropertyInputBase;
+    }>;
+}
+export interface PropertyInputData<Value = any, Properties extends object = any> {
+    type: string;
+    properties: Properties;
+    disabled?: boolean;
+    mode?: string;
+    required?: boolean;
+    validator?: string;
+}
+export interface PropertyInputMetaData {
+    id: string;
+    name: string;
+    [key: string]: any;
+}
+export interface PropertyInputConstructor<Value = any, Properties extends object = any> {
+    Meta: PropertyInputMetaData;
+    Create(overrides: Partial<PropertyInputData<Value, Properties>>): PropertyInputData<Value, Properties>;
+    new (data: PropertyInputData<Value, Properties>, node: SchemaNode): PropertyInputBase<Value, Properties>;
+}
+export interface PropertyInputBase {
+    init?(): void;
+}
+export declare abstract class PropertyInputBase<Value = any, Properties extends object = any> {
+    data: PropertyInputData<Value, Properties>;
+    node: SchemaNode;
+    static CreateBase<Value = any, Properties extends object = any>(data: Partial<PropertyInputConstructor<Value, Properties>>): PropertyInputData<Value, Properties>;
+    pipelines: PropertyInputPipelines<any>;
+    constructor(data: PropertyInputData<Value, Properties>, node: SchemaNode);
+    abstract compare(value1: Value, value2: Value): boolean;
+    get(): any;
+    set(newValue: Value): void;
+    abstract getClass(): PropertyInputConstructor<Value, Properties>;
+    abstract getMeta(): PropertyInputMetaData;
+}
+export {};

package/Inputs/PropertyInput.js

@@ -0,0 +1,35 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+class PropertyInputPipelines {
+    onGet = new Pipeline();
+    onSet = new Pipeline();
+}
+export class PropertyInputBase {
+    data;
+    node;
+    static CreateBase(data) {
+        return {
+            type: "",
+            properties: {},
+            ...data,
+        };
+    }
+    pipelines = new PropertyInputPipelines();
+    constructor(data, node) {
+        this.data = data;
+        this.node = node;
+        if (this.init)
+            this.init();
+    }
+    get() {
+        return this.pipelines.onGet.pipe({
+            input: this,
+            value: this.node.get(),
+        }).value;
+    }
+    set(newValue) {
+        this.node.update(this.pipelines.onSet.pipe({
+            input: this,
+            newValue,
+        }).newValue);
+    }
+}

package/Inputs/PropertyInputRegister.d.ts

@@ -0,0 +1,7 @@
+import { ArrayMap } from "@amodx/core/DataStructures/ArrayMap";
+import { PropertyInputConstructor } from "./PropertyInput";
+export declare class PropertyInputRegister {
+    static properties: ArrayMap<string, PropertyInputConstructor<any, any>>;
+    static regsiterProperty(...data: PropertyInputConstructor[]): void;
+    static getProperty(id: string): PropertyInputConstructor<any, any>;
+}

package/Inputs/PropertyInputRegister.js

@@ -0,0 +1,13 @@
+import { ArrayMap } from "@amodx/core/DataStructures/ArrayMap";
+export class PropertyInputRegister {
+    static properties = new ArrayMap();
+    static regsiterProperty(...data) {
+        this.properties.add(data.map((_) => [_.Meta.id, _]));
+    }
+    static getProperty(id) {
+        const property = this.properties.get(id);
+        if (!property)
+            throw new Error(`Property with id ${id} does not exist`);
+        return property;
+    }
+}

package/Properties/ObjectPath.d.ts

@@ -0,0 +1,17 @@
+type QueryPathTree<T> = {
+    [P in keyof T]-?: T[P] extends (infer U)[] ? [P] | [P, number] | [P, number, ...QueryPath<U>] : T[P] extends object ? [P] | [P, ...QueryPath<T[P]>] : [P];
+};
+export type QueryPath<T> = QueryPathTree<T>[keyof T];
+type QueryPathValue<T, P extends any[]> = P extends [infer K, ...infer Rest] ? K extends keyof T ? Rest extends [] ? T[K] : Rest extends [number, ...infer R] ? T[K] extends (infer U)[] ? R extends [] ? U : QueryPathValue<U, R> : never : QueryPathValue<T[K], Rest> : never : never;
+export declare class ObjectPath<Data extends object, Path extends QueryPath<Data>> {
+    path: Path;
+    static Create<Data extends object, Path extends QueryPath<Data> = any>(path: Path): ObjectPath<Data, typeof path>;
+    static Generator<Data extends object>(): <Path extends QueryPath<Data>>(path: Path) => ObjectPath<Data, Path>;
+    private propertyPath;
+    private constructor();
+    private resolvePath;
+    private resolveParentPath;
+    get(obj: Data): QueryPathValue<Data, Path>;
+    set(obj: Data, value: QueryPathValue<Data, Path>): void;
+}
+export {};