@amodx/ncs 0.0.1 → 0.0.2

package/Schema/Functions/createSchemaIndex.js

@@ -0,0 +1,18 @@
+function traverse(parent, properties) {
+    for (let i = 0; i < properties.length; i++) {
+        const property = properties[i];
+        const index = property.index;
+        if (!property.children) {
+            parent[property.id] = index;
+            continue;
+        }
+        const newParent = {};
+        traverse(newParent, property.children);
+        parent[property.id] = newParent;
+    }
+}
+export function createSchemaIndex(schema) {
+    const data = {};
+    traverse(data, schema.root.children);
+    return data;
+}

package/Schema/Functions/createSchemaObjectCursorClass.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "../Schema";
+import { SchemaArray } from "../../Schema/SchemaArray";
+import { SchemaArrayCursor } from "../SchemaArrayCursor";
+export declare function createSchemaObjectCursorClass(schema: Schema): {
+    new (__view: import("../SchemaView").SchemaView<any>): {
+        __cursor: SchemaArrayCursor;
+        __cursors: never[];
+        __view: import("../SchemaView").SchemaView<any>;
+        __array: SchemaArray;
+        __index: number;
+        setInstance(index: number): void;
+        getInstance(): number;
+        getCursor(): SchemaArrayCursor;
+        getSchemaIndex(): import("../Schema.types").SchemaCursorIndex<any>;
+        clone(): any;
+        toJSON(): any;
+    };
+};

package/Schema/Functions/createSchemaObjectCursorClass.js

@@ -0,0 +1,66 @@
+import { createBaseSchemaCursor } from "./createBaseSchemaCursor";
+function traverse(parent, properties) {
+    for (let i = 0; i < properties.length; i++) {
+        const property = properties[i];
+        const index = property.index;
+        if (!property.children) {
+            Object.defineProperty(parent.prototype, property.id, {
+                get() {
+                    if (this.__cursor.hasProxy(index)) {
+                        return this.__cursor.fetchProxyData(index);
+                    }
+                    return this.__cursor.data[index];
+                },
+                set(value) {
+                    let obs = this.__cursor.getObserver(index);
+                    let proxy = this.__cursor.hasProxy(index);
+                    if (obs) {
+                        const oldVale = proxy
+                            ? this.__cursor.fetchProxyData(index)
+                            : this.__cursor.data[index];
+                        if (oldVale != value) {
+                            this.__cursor.data[index] = value;
+                            if (proxy) {
+                                this.__cursor.setProxyData(index, value);
+                            }
+                            obs.notify(value);
+                            return;
+                        }
+                    }
+                    this.__cursor.data[index] = value;
+                    if (proxy) {
+                        this.__cursor.setProxyData(index, value);
+                    }
+                },
+            });
+            continue;
+        }
+        class SchemaCursorProperty {
+            __cursor;
+            __cursors;
+            constructor(__cursor, __cursors) {
+                this.__cursor = __cursor;
+                this.__cursors = __cursors;
+            }
+        }
+        traverse(SchemaCursorProperty, property.children);
+        Object.defineProperty(parent.prototype, property.id, {
+            get() {
+                let v = this.__cursors[index];
+                if (!v) {
+                    v = new SchemaCursorProperty(this.__cursor, this.__cursors);
+                    this.__cursors[index] = v;
+                }
+                return v;
+            },
+            set(value) {
+                //  (this as SchemaClassBase).__data.current[index] = value;
+            },
+        });
+    }
+}
+export function createSchemaObjectCursorClass(schema) {
+    const SchemaCursor = createBaseSchemaCursor();
+    traverse(SchemaCursor, schema.root.children);
+    return SchemaCursor;
+}

package/Schema/Functions/createSchemaTypedArrayCursorClass.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from "../Schema";
+import { SchemaArrayCursor } from "Schema/SchemaArrayCursor";
+export declare function createSchemaTypedArrayCursorClass(schema: Schema): {
+    new (__view: import("../SchemaView").SchemaView<any>): {
+        __cursor: SchemaArrayCursor;
+        __cursors: never[];
+        __view: import("../SchemaView").SchemaView<any>;
+        __array: import("../SchemaArray").SchemaArray;
+        __index: number;
+        setInstance(index: number): void;
+        getInstance(): number;
+        getCursor(): SchemaArrayCursor;
+        getSchemaIndex(): import("../Schema.types").SchemaCursorIndex<any>;
+        clone(): any;
+        toJSON(): any;
+    };
+};

package/Schema/Functions/createSchemaTypedArrayCursorClass.js

@@ -0,0 +1,66 @@
+import { createBaseSchemaCursor } from "./createBaseSchemaCursor";
+function traverse(parent, properties) {
+    for (let i = 0; i < properties.length; i++) {
+        const property = properties[i];
+        const index = property.index;
+        if (!property.children) {
+            Object.defineProperty(parent.prototype, property.id, {
+                get() {
+                    if (this.__cursor.hasProxy(index)) {
+                        return this.__cursor.fetchProxyData(index);
+                    }
+                    return this.__cursor.data[index];
+                },
+                set(value) {
+                    let obs = this.__cursor.getObserver(index);
+                    let proxy = this.__cursor.hasProxy(index);
+                    if (obs) {
+                        const oldVale = proxy
+                            ? this.__cursor.fetchProxyData(index)
+                            : this.__cursor.data[index];
+                        if (oldVale != value) {
+                            this.__cursor.data[index] = value;
+                            if (proxy) {
+                                this.__cursor.setProxyData(index, value);
+                            }
+                            obs.notify(value);
+                            return;
+                        }
+                    }
+                    this.__cursor.data[index] = value;
+                    if (proxy) {
+                        this.__cursor.setProxyData(index, value);
+                    }
+                },
+            });
+            continue;
+        }
+        class SchemaCursorProperty {
+            __cursor;
+            __cursors;
+            constructor(__cursor, __cursors) {
+                this.__cursor = __cursor;
+                this.__cursors = __cursors;
+            }
+        }
+        traverse(SchemaCursorProperty, property.children);
+        Object.defineProperty(parent.prototype, property.id, {
+            get() {
+                let v = this.__cursors[index];
+                if (!v) {
+                    v = new SchemaCursorProperty(this.__cursor, this.__cursors);
+                    this.__cursors[index] = v;
+                }
+                return v;
+            },
+            set(value) {
+                //  (this as SchemaClassBase).__data.current[index] = value;
+            },
+        });
+    }
+}
+export function createSchemaTypedArrayCursorClass(schema) {
+    const SchemaCursor = createBaseSchemaCursor();
+    traverse(SchemaCursor, schema.root.children);
+    return SchemaCursor;
+}

package/Schema/Property/Property.d.ts

@@ -0,0 +1,11 @@
+import { PropertyData, PropertyMetaData } from "./Property.types";
+export declare class Property implements PropertyData {
+    readonly index: number;
+    id: string;
+    name?: string;
+    type: string;
+    meta?: PropertyMetaData;
+    value: null;
+    children?: Property[];
+    constructor(data: PropertyData, index: number);
+}

package/Schema/Property/Property.js

@@ -0,0 +1,16 @@
+export class Property {
+    index;
+    id = "";
+    name;
+    type = "";
+    meta;
+    value = null;
+    children;
+    constructor(data, index) {
+        this.index = index;
+        this.id = data.id;
+        this.name = data.name;
+        this.value = data.value;
+        this.meta = data.meta;
+    }
+}

package/Schema/Property/Property.types.d.ts

@@ -0,0 +1,26 @@
+export interface PropertyData<Meta extends {} = {}> {
+    id: string;
+    name?: string;
+    value: any;
+    meta?: PropertyMetaData<Meta>;
+    children?: PropertyData[];
+}
+export type BinaryPropertyTypes = "i8" | "ui8" | "i16" | "ui16" | "i32" | "ui32" | "f32" | "f64";
+export type TypedArrays = typeof Int8Array | typeof Uint8Array | typeof Int16Array | typeof Uint16Array | typeof Int32Array | typeof Uint32Array | typeof Float32Array | typeof Float64Array;
+export declare const TypedArrayMap: Record<BinaryPropertyTypes, TypedArrays>;
+export declare const BinaryPropertyTypeSizeMap: Record<BinaryPropertyTypes, number>;
+export type BinaryPropertyData = BinaryPropertyTypes | {
+    byteSize: number;
+    set(data: DataView, meta: any, index: number, value: any): void;
+    get(data: DataView, meta: any, index: number): any;
+};
+export type PropertyMetaData<MetaData extends {} = any> = {
+    binary?: BinaryPropertyData;
+    data?: MetaData;
+    /**If the property was created from an object */
+    child?: true;
+    type?: string;
+    units?: string;
+    options?: string[] | [string, string | number][];
+    name?: string;
+};

package/Schema/Property/Property.types.js

@@ -0,0 +1,20 @@
+export const TypedArrayMap = {
+    i8: Int8Array,
+    ui8: Uint8Array,
+    i16: Int16Array,
+    ui16: Uint16Array,
+    i32: Int32Array,
+    ui32: Uint32Array,
+    f32: Float32Array,
+    f64: Float64Array,
+};
+export const BinaryPropertyTypeSizeMap = {
+    i8: Int8Array.BYTES_PER_ELEMENT,
+    ui8: Uint8Array.BYTES_PER_ELEMENT,
+    i16: Int16Array.BYTES_PER_ELEMENT,
+    ui16: Uint16Array.BYTES_PER_ELEMENT,
+    i32: Int32Array.BYTES_PER_ELEMENT,
+    ui32: Uint32Array.BYTES_PER_ELEMENT,
+    f32: Float32Array.BYTES_PER_ELEMENT,
+    f64: Float64Array.BYTES_PER_ELEMENT,
+};

package/Schema/Schema.d.ts

@@ -0,0 +1,28 @@
+import { Property } from "./Property/Property";
+import { BinaryPropertyTypes, PropertyMetaData } from "./Property/Property.types";
+import { SchemaData, SchemaCursorIndex, SchemaCreateData, SchemaMetaOverrideData } from "./Schema.types";
+import { SchemaView } from "./SchemaView";
+import { RecursivePartial } from "../Util/Util.types";
+import { SchemaArray } from "./SchemaArray";
+import { IdPalette } from "../Util/IdPalette";
+export declare class Schema<Shape extends Record<string, any> = {}> {
+    static FromObject<Shape extends Record<string, any>>(shape: Shape): Schema<Shape>;
+    readonly root: Property;
+    private _objectCursorClass;
+    private _typedArrayCursorClass;
+    private _binaryObjectCursorClass;
+    readonly index: SchemaCursorIndex<Shape>;
+    readonly shape: Shape;
+    readonly _data: any[];
+    readonly _meta: PropertyMetaData[];
+    viewIdPalettew: IdPalette;
+    views: SchemaView[];
+    array: SchemaArray;
+    constructor(data: SchemaData);
+    createData(newData: any[] | undefined, overrides: RecursivePartial<Shape>): any[];
+    getView(id: string): SchemaView<any> | null;
+    createView(data: SchemaCreateData): SchemaView<any>;
+    createObjectView(id: string, meta?: SchemaMetaOverrideData | null): SchemaView<Shape>;
+    createBinaryObjectView(id: string, sharedMemory?: boolean, meta?: SchemaMetaOverrideData | null): SchemaView<Shape>;
+    createTypedArrayView(id: string, arrayType: BinaryPropertyTypes, sharedMemory?: boolean, meta?: SchemaMetaOverrideData | null): SchemaView<Shape>;
+}

package/Schema/Schema.js

@@ -0,0 +1,223 @@
+import { createSchemaObjectCursorClass } from "./Functions/createSchemaObjectCursorClass";
+import { createSchemaIndex } from "./Functions/createSchemaIndex";
+import { Property } from "./Property/Property";
+import { BinaryPropertyTypeSizeMap, } from "./Property/Property.types";
+import { createSchemaTypedArrayCursorClass } from "./Functions/createSchemaTypedArrayCursorClass";
+import { createSchemaBinaryObjectCursorClass } from "./Functions/createSchemaBinaryObjectCursorClass";
+import { SchemaView } from "./SchemaView";
+import { SchemaArray } from "./SchemaArray";
+import { IdPalette } from "../Util/IdPalette";
+const traverseCreate = (parent, properties, index) => {
+    parent.children ??= [];
+    for (let i = 0; i < properties.length; i++) {
+        const data = properties[i];
+        if (typeof data.value == "object" && !data.children) {
+            data.children ??= [];
+            for (const key in data.value) {
+                const value = data.value[key];
+                const meta = structuredClone(data.meta || {});
+                meta.child = true;
+                data.children.push({
+                    id: key,
+                    meta,
+                    value,
+                });
+            }
+        }
+        if (data.children) {
+            const newChild = new Property(data, index + 1);
+            parent.children.push(newChild);
+            index = traverseCreate(newChild, data.children, index);
+            continue;
+        }
+        else {
+            index++;
+            parent.children.push(new Property(data, index));
+        }
+    }
+    return index;
+};
+const buildBinaryData = (meta) => {
+    let byteSize = 0;
+    const byteOffsets = [];
+    for (let i = 0; i < meta.length; i++) {
+        const metaData = meta[i];
+        if (!metaData || !metaData.binary)
+            continue;
+        byteOffsets[i] = byteSize;
+        if (typeof metaData.binary == "object") {
+            byteSize += metaData.binary.byteSize;
+            continue;
+        }
+        if (typeof metaData.binary == "string") {
+            byteSize += BinaryPropertyTypeSizeMap[metaData.binary];
+            continue;
+        }
+    }
+    return { byteSize, byteOffsets };
+};
+const traverseArray = (parent, data, meta) => {
+    for (let i = 0; i < parent.children.length; i++) {
+        const property = parent.children[i];
+        if (!property.children) {
+            data[Number(property.index)] = structuredClone(property.value);
+            property.meta && (meta[property.index] = structuredClone(property.meta));
+        }
+        else {
+            traverseArray(property, data, meta);
+        }
+    }
+    return data;
+};
+function buildMeta(data, meta, metaOverrides) {
+    let newMeta = [...meta];
+    for (let i = 0; i < data.length; i++) {
+        if (!metaOverrides[i])
+            continue;
+        newMeta[i] = metaOverrides[i];
+    }
+    return newMeta;
+}
+function traverseCreateFromObject(object, property) {
+    for (const id in object) {
+        const value = object[id];
+        if (typeof value == "object") {
+            property.children.push(traverseCreateFromObject(value, {
+                id,
+                value: {},
+                children: [],
+            }));
+        }
+        else {
+            property.children.push({
+                id,
+                value,
+            });
+        }
+    }
+    return property;
+}
+function traverseCreateData(parent, target, source) {
+    for (const property of parent.children) {
+        if (typeof source[property.id] === "undefined")
+            continue;
+        if (property.children) {
+            traverseCreateData(property, target, source[property.id]);
+        }
+        else {
+            target[property.index] = source[property.id];
+        }
+    }
+    return target;
+}
+export class Schema {
+    static FromObject(shape) {
+        const data = [];
+        for (const id in shape) {
+            const value = shape[id];
+            if (typeof value == "object") {
+                data.push(traverseCreateFromObject(value, {
+                    id,
+                    value: {},
+                    children: [],
+                }));
+            }
+            else {
+                data.push({
+                    id,
+                    value,
+                });
+            }
+        }
+        return new Schema(data);
+    }
+    root = new Property({
+        id: "__root__",
+        meta: {},
+        value: {},
+    }, -1);
+    _objectCursorClass;
+    _typedArrayCursorClass;
+    _binaryObjectCursorClass;
+    index;
+    shape;
+    _data = [];
+    _meta = [];
+    viewIdPalettew = new IdPalette();
+    views = [];
+    array;
+    constructor(data) {
+        traverseCreate(this.root, data, -1);
+        this.index = createSchemaIndex(this);
+        traverseArray(this.root, this._data, this._meta);
+        this.createObjectView("default");
+        this.array = new SchemaArray(this);
+    }
+    createData(newData = [], overrides) {
+        for (let i = 0; i < this._data.length; i++) {
+            newData[i] =
+                typeof this._data[i] == "object"
+                    ? structuredClone(this._data[i])
+                    : this._data[i];
+        }
+        traverseCreateData(this.root, newData, overrides);
+        return newData;
+    }
+    getView(id) {
+        if (!this.viewIdPalettew.isRegistered(id))
+            return null;
+        return this.views[this.viewIdPalettew.getNumberId(id)];
+    }
+    createView(data) {
+        let view = null;
+        let meta = this._meta;
+        if (data.meta)
+            meta = buildMeta(this._data, meta, data.meta);
+        if (data.type == "object") {
+            if (!this._objectCursorClass)
+                this._objectCursorClass = createSchemaObjectCursorClass(this);
+            view = new SchemaView(this, data.id, meta, [], 0, data, this._objectCursorClass);
+        }
+        if (data.type == "typed-array") {
+            if (!this._typedArrayCursorClass)
+                this._typedArrayCursorClass = createSchemaTypedArrayCursorClass(this);
+            view = new SchemaView(this, data.id, meta, [], 0, data, this._typedArrayCursorClass);
+        }
+        if (data.type == "binary-object") {
+            if (!this._binaryObjectCursorClass)
+                this._binaryObjectCursorClass =
+                    createSchemaBinaryObjectCursorClass(this);
+            const { byteSize, byteOffsets } = buildBinaryData(meta);
+            view = new SchemaView(this, data.id, meta, byteOffsets, byteSize, data, this._binaryObjectCursorClass);
+        }
+        if (!view)
+            throw new Error(`Invalid data`);
+        const viewIndex = this.viewIdPalettew.register(data.id);
+        this.views[viewIndex] = view;
+        return view;
+    }
+    createObjectView(id, meta = null) {
+        return this.createView({
+            id,
+            type: "object",
+            meta,
+        });
+    }
+    createBinaryObjectView(id, sharedMemory = false, meta = null) {
+        return this.createView({
+            id,
+            type: "binary-object",
+            meta,
+            sharedMemory: sharedMemory || undefined,
+        });
+    }
+    createTypedArrayView(id, arrayType, sharedMemory = false, meta = null) {
+        return this.createView({
+            id,
+            type: "typed-array",
+            meta,
+            arrayType,
+            sharedMemory: sharedMemory || undefined,
+        });
+    }
+}

package/Schema/Schema.types.d.ts

@@ -0,0 +1,59 @@
+import { BinaryPropertyTypes, PropertyData, PropertyMetaData } from "./Property/Property.types";
+import { SchemaView } from "./SchemaView";
+import { SchemaArrayCursor } from "./SchemaArrayCursor";
+export type SchemaTypes = "object" | "binay";
+export type SchemaData = PropertyData[];
+export type SchemaProxyData<T extends Record<string | number, any> = {}> = [
+    object: T,
+    key: keyof T
+];
+export type BinaryObjectSchemaView = {
+    view: DataView;
+    buffer: Uint8Array;
+};
+export type SchemaCursor<Shape extends {} = {}> = SchemaCursorBase<Shape> & Shape;
+export interface SchemaCursorBase<Shape extends {} = any> {
+    __view: SchemaView<Shape>;
+    __cursor: SchemaArrayCursor;
+    getSchemaIndex(): SchemaCursorIndex<Shape>;
+    getInstance(): number;
+    setInstance(index: number): void;
+    getCursor(): SchemaArrayCursor;
+    clone(): SchemaCursorBase<Shape>;
+    toJSON(): Shape;
+}
+export type SchemaMetaOverrideData = PropertyMetaData[] | Record<number, PropertyMetaData>;
+export type SchemaCreateData = {
+    id: string;
+    type: "object";
+    meta?: SchemaMetaOverrideData | null;
+} | {
+    id: string;
+    type: "typed-array";
+    arrayType: BinaryPropertyTypes;
+    sharedMemory?: true;
+    meta?: SchemaMetaOverrideData | null;
+} | {
+    id: string;
+    type: "binary-object";
+    sharedMemory?: true;
+    meta?: SchemaMetaOverrideData | null;
+};
+export interface SchemaCursorClassBase extends SchemaCursorBase {
+    __index: number;
+    __cursor: SchemaArrayCursor;
+    __cursors: any[];
+}
+export type SchemaCursorIndex<T> = {
+    [K in keyof T]: T[K] extends string | number | boolean | bigint | symbol | undefined | null ? number : T[K] extends object ? SchemaCursorIndex<T[K]> : never;
+};
+export declare class SchemaProperty<T extends any> {
+    value: T;
+    meta: PropertyMetaData;
+    constructor(value: T, meta: PropertyMetaData);
+}
+export type ExtractSchemaClass<T> = T extends SchemaProperty<infer U> ? U extends object ? {
+    [K in keyof U]: ExtractSchemaClass<U[K]>;
+} : U : T extends object ? {
+    [K in keyof T]: ExtractSchemaClass<T[K]>;
+} : T;

package/Schema/Schema.types.js

@@ -0,0 +1,8 @@
+export class SchemaProperty {
+    value;
+    meta;
+    constructor(value, meta) {
+        this.value = value;
+        this.meta = meta;
+    }
+}

package/Schema/SchemaArray.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from "../Util/Observable";
+import { BinaryObjectSchemaView } from "./Schema.types";
+import { Schema } from "./Schema";
+export declare class SchemaArray {
+    schema: Schema;
+    _data: (any[] | BinaryObjectSchemaView)[];
+    _dataViews: number[];
+    _observers: Observable<any>[][];
+    _proxyObjects: any[][];
+    _proxyKeys: any[][];
+    constructor(schema: Schema);
+    createViewCursor(index: number): any;
+    setData(index: number, data: any, view?: string | null): void;
+    getViewAt(index: number): import("./SchemaView").SchemaView<any> | null;
+    removeData(index: number): boolean;
+    getObserver(propertyIndex: number, arrayIndex: number): Observable<any> | null;
+    setObserver(propertyIndex: number, arrayIndex: number, value: Observable<any> | null): void;
+    hasProxy(propertyIndex: number, arrayIndex: number): boolean;
+    fetchProxyData(propertyIndex: number, arrayIndex: number): any;
+    setProxyData(propertyIndex: number, arrayIndex: number, value: any): void;
+    removeProxy(propertyIndex: number, arrayIndex: number): void;
+    setProxy<T extends Record<string | number, any> = {}>(propertyIndex: number, arrayIndex: number, object: T, key: keyof T): void;
+}