@amodx/schemas 0.0.1 → 0.0.21

package/Inputs/DefaultInputs.js

@@ -1,376 +1,149 @@
-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,
-        };
-    }
+import { registerInput } from "./registerInput";
+const StringInput = registerInput({
+    id: "string",
+    name: "String",
     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) {
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: Vec2Input.Meta.id,
-            properties: {
-                valueType: "position",
-            },
-            ...data,
+            min: 0,
+            max: Number.MAX_SAFE_INTEGER,
+            ...properties,
         };
-    }
+    },
+});
+const HEXColorInput = registerInput({
+    id: "hex-color",
+    name: "Hex Color",
     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 value1 === value2;
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: Vec3Input.Meta.id,
-            properties: {
-                valueType: "position",
-            },
-            ...data,
+            ...properties,
         };
-    }
+    },
+});
+const Color3Input = registerInput({
+    id: "color3",
+    name: "Color3",
     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 (value1.r === value2.r && value1.g === value2.g && value1.b == value2.b);
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: IntInput.Meta.id,
-            properties: {
-                min: 0,
-                max: Number.MAX_SAFE_INTEGER,
-            },
-            ...data,
+            ...properties,
         };
-    }
+    },
+});
+const Color4Input = registerInput({
+    id: "color4",
+    name: "Color4",
     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 (value1.r === value2.r &&
+            value1.g === value2.g &&
+            value1.b == value2.b &&
+            value1.a == value2.a);
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: SelectInput.Meta.id,
-            properties: {
-                options: [],
-            },
-            ...data,
+            ...properties,
         };
-    }
+    },
+});
+const RangeInput = registerInput({
+    id: "range",
+    name: "Range",
     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 value1 === value2;
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: FilePathInput.Meta.id,
-            properties: {
-                acceptedFileExtensions: [],
-            },
-            ...data,
+            min: 0,
+            max: Number.MAX_SAFE_INTEGER,
+            step: 1,
+            ...properties,
         };
-    }
+    },
+});
+const FloatInput = registerInput({
+    id: "float",
+    name: "Float",
     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 value1 === value2;
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: PasswordInput.Meta.id,
-            properties: {
-                min: 0,
-                max: Number.MAX_SAFE_INTEGER,
-            },
-            ...data,
+            min: 0,
+            max: Number.MAX_SAFE_INTEGER,
+            ...properties,
         };
-    }
+    },
+});
+const Vec2Input = registerInput({
+    id: "vec2",
+    name: "Vec2",
     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 value1.x === value2.x && value1.y === value2.y;
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: CheckboxInput.Meta.id,
-            properties: {},
-            ...data,
+            valueType: "position",
+            ...properties,
         };
-    }
+    },
+});
+const Vec3Input = registerInput({
+    id: "vec3",
+    name: "Vec3",
     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 (value1.x === value2.x && value1.y === value2.y && value1.z === value2.z);
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: DateInput.Meta.id,
-            properties: {},
-            ...data,
+            valueType: "position",
+            ...properties,
         };
-    }
+    },
+});
+const IntInput = registerInput({
+    id: "int",
+    name: "Int",
     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 value1 === value2;
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: TextareaInput.Meta.id,
-            properties: {
-                rows: 4,
-                cols: 50,
-            },
-            ...data,
+            min: 0,
+            max: Number.MAX_SAFE_INTEGER,
+            ...properties,
         };
-    }
+    },
+});
+const SelectInput = registerInput({
+    id: "select",
+    name: "Select",
     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 value1 === value2;
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: EmailInput.Meta.id,
-            properties: {},
-            ...data,
+            options: [],
+            ...properties,
         };
-    }
+    },
+});
+const BooleanInput = registerInput({
+    id: "boolean",
+    name: "Boolean",
     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 value1 === value2;
+    },
+    createProperties(properties) {
         return {
-            ...PropertyInputBase.CreateBase({}),
-            type: UrlInput.Meta.id,
-            properties: {},
-            ...data,
+            ...properties,
         };
-    }
-    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, };
+    },
+});
+export { HEXColorInput as HexColorPropertyInput, Color3Input as Color3PropertyInput, Color4Input as Color4PropertyInput, RangeInput as RangePropertyInput, FloatInput as FloatPropertyInput, Vec2Input as Vec2PropertyInput, Vec3Input as Vec3PropertyInput, IntInput as IntPropertyInput, StringInput as StringPropertyInput, SelectInput as SelectPropertyInput, BooleanInput as BooleanPropertyInput, };

package/Inputs/PropertyInput.d.ts

@@ -1,46 +1,44 @@
 import { Pipeline } from "@amodx/core/Pipelines";
 import { SchemaNode } from "../Schemas/SchemaNode";
+type GetPipelineData<Value = any> = {
+    value: Value;
+    input: PropertyInputBase;
+};
+type SetPipelineData<Value = any> = {
+    newValue: Value;
+    input: PropertyInputBase;
+};
 declare class PropertyInputPipelines<Value = any> {
-    onGet: Pipeline<{
-        value: Value;
-        input: PropertyInputBase;
-    }>;
-    onSet: Pipeline<{
-        newValue: any;
-        input: PropertyInputBase;
-    }>;
+    onGet: Pipeline<GetPipelineData<Value>>;
+    onSet: Pipeline<SetPipelineData<Value>>;
 }
-export interface PropertyInputData<Value = any, Properties extends object = any> {
-    type: string;
-    properties: Properties;
+export interface PropertyInputBaseProperties {
     disabled?: boolean;
-    mode?: string;
     required?: boolean;
     validator?: string;
+    variation?: 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 PropertyInputData<Value = any, Properties extends PropertyInputBaseProperties = PropertyInputBaseProperties> {
+    type: string;
+    properties: Properties;
 }
-export interface PropertyInputBase {
-    init?(): void;
+export interface AbstractPropertyInput<Value extends any = any, Properties extends PropertyInputBaseProperties = PropertyInputBaseProperties> {
+    id: string;
+    name?: string;
+    init?(input: PropertyInputBase<Value, Properties>): void;
+    createProperties(properties: Partial<Properties>): Properties;
+    compare(value1: Value, value2: Value): boolean;
 }
-export declare abstract class PropertyInputBase<Value = any, Properties extends object = any> {
+export declare class PropertyInputBase<Value = any, Properties extends PropertyInputBaseProperties = PropertyInputBaseProperties> {
+    abstractInput: AbstractPropertyInput<Value>;
     data: PropertyInputData<Value, Properties>;
     node: SchemaNode;
-    static CreateBase<Value = any, Properties extends object = any>(data: Partial<PropertyInputConstructor<Value, Properties>>): PropertyInputData<Value, Properties>;
+    private _getData;
+    private _setData;
     pipelines: PropertyInputPipelines<any>;
-    constructor(data: PropertyInputData<Value, Properties>, node: SchemaNode);
-    abstract compare(value1: Value, value2: Value): boolean;
+    constructor(abstractInput: AbstractPropertyInput<Value>, data: PropertyInputData<Value, Properties>, node: SchemaNode);
+    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

@@ -4,32 +4,36 @@ class PropertyInputPipelines {
     onSet = new Pipeline();
 }
 export class PropertyInputBase {
+    abstractInput;
     data;
     node;
-    static CreateBase(data) {
-        return {
-            type: "",
-            properties: {},
-            ...data,
-        };
-    }
+    _getData;
+    _setData;
     pipelines = new PropertyInputPipelines();
-    constructor(data, node) {
+    constructor(abstractInput, data, node) {
+        this.abstractInput = abstractInput;
         this.data = data;
         this.node = node;
-        if (this.init)
-            this.init();
-    }
-    get() {
-        return this.pipelines.onGet.pipe({
+        this._getData = {
             input: this,
             value: this.node.get(),
-        }).value;
+        };
+        this._setData = {
+            input: this,
+            newValue: this.node.get(),
+        };
+        if (abstractInput.init)
+            abstractInput.init(this);
+    }
+    compare(value1, value2) {
+        return this.abstractInput.compare(value1, value2);
+    }
+    get() {
+        this._getData.value = this.node.get();
+        return this.pipelines.onGet.pipe(this._getData).value;
     }
     set(newValue) {
-        this.node.update(this.pipelines.onSet.pipe({
-            input: this,
-            newValue,
-        }).newValue);
+        this._setData.newValue = newValue;
+        this.node.update(this.pipelines.onSet.pipe(this._setData).newValue);
     }
 }

package/Inputs/PropertyInputRegister.d.ts

@@ -1,7 +1,7 @@
 import { ArrayMap } from "@amodx/core/DataStructures/ArrayMap";
-import { PropertyInputConstructor } from "./PropertyInput";
+import { AbstractPropertyInput } 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>;
+    static properties: ArrayMap<string, AbstractPropertyInput<any, any>>;
+    static regsiterProperty(data: AbstractPropertyInput): void;
+    static getProperty(id: string): AbstractPropertyInput<any, any>;
 }

package/Inputs/PropertyInputRegister.js

@@ -1,8 +1,8 @@
 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 regsiterProperty(data) {
+        this.properties.set(data.id, data);
     }
     static getProperty(id) {
         const property = this.properties.get(id);

package/Inputs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./registerInput";
+export * from "./PropertyInput";

package/Inputs/index.js

@@ -0,0 +1,2 @@
+export * from "./registerInput";
+export * from "./PropertyInput";

package/Inputs/registerInput.d.ts

@@ -0,0 +1,18 @@
+import { PropertyFC, PropertyRenderFC } from "Property.types";
+import { AbstractPropertyInput, PropertyInputBase, PropertyInputBaseProperties, PropertyInputData } from "./PropertyInput";
+import { SchemaNode } from "../Schemas/SchemaNode";
+export type RegisteredInput<Value extends any = any, Properties extends PropertyInputBaseProperties = PropertyInputBaseProperties> = ((initalProperties?: Partial<Properties>) => PropertyInputData<Value, Properties>) & {
+    id: string;
+    meta: {
+        name: string;
+    };
+    default: PropertyInputBase<Value, Properties>;
+    data: PropertyInputData<Value, Properties>;
+    properties: Properties;
+    value: Value;
+    createPropertyFC(defaultValue: Value): PropertyFC<Value, PropertyInputBase<Value, Properties>>;
+    createPropertyRenderFC<RenderedData extends any = any, Props extends any = any>(fc: (props: {
+        node: SchemaNode<Value, PropertyInputBase<Value, Properties>>;
+    } & Props) => RenderedData): PropertyRenderFC<RenderedData, Value, PropertyInputBase<Value, Properties>, Props>;
+};
+export declare function registerInput<Value extends any, InitalProperties extends object = {}>(data: AbstractPropertyInput<Value, InitalProperties>): RegisteredInput<Value, PropertyInputBaseProperties & InitalProperties>;