@amodx/ncs 0.0.1 → 0.0.21

package/Components/Component.types.d.ts

@@ -0,0 +1,78 @@
+import { Schema } from "../Schema/Schema";
+import { ComponentCursor } from "./ComponentCursor";
+import { RecursivePartial } from "../Util/Util.types";
+export type CreateComponentData<ComponentSchema extends object = any> = [
+    /**
+     * The type of the component.
+     */
+    type: string,
+    /**
+     * The ComponentSchema of the component.
+     */
+    schema: RecursivePartial<ComponentSchema> | any | null,
+    /**
+     * The schema view id  of the component.
+     */
+    schemaViewId: string | null,
+    /**
+     * Wether or not if the component is remote.
+     */
+    remote: true | null
+];
+/**
+ * Interface representing the meta data of a component.
+ */
+export interface ComponentMetaData {
+    name: string;
+    [key: string]: any;
+}
+/**
+ * Type representing the data required to register a component.
+ *
+ * Used for serlization and creation.
+ * @template ComponentSchema - The schema of the component.
+ * @template Data - The runtime data of the component.
+ * @template Logic - The logic functions of the component.
+ * @template Shared - The shared data of all components of this type.
+ * @template Meta - The shared meta data of all components of this type.
+ */
+export type ComponentRegisterData<ComponentSchema extends object = any, Data extends any = any, Shared extends any = any> = {
+    /**
+     * The type of the component.
+     */
+    type: string;
+    /**
+     * The schema used to create an editable version of the component.
+     * For the actual ComponentInstance the schema is created into an object.
+     */
+    schema?: Schema<ComponentSchema>;
+    data?: Data;
+    /**
+     * The shared data of all components.
+     */
+    shared?: Shared;
+    /**
+     * The shared meta data of all components.
+     */
+    meta?: ComponentMetaData;
+    /**
+     * Optional initialization function for the component.
+     *
+     * @param component - The instance of the component being initialized.
+     */
+    init?(component: ComponentCursor<ComponentSchema, Data, Shared>): void;
+    /**
+     * Optional update function for the component.
+     * The update function is usually called once per frame.
+     * It is up to the graph though when it gets called.
+     *
+     * @param component - The instance of the component being updated.
+     */
+    update?(component: ComponentCursor<ComponentSchema, Data, Shared>): void;
+    /**
+     * Optional disposal function for the component.
+     *
+     * @param component - The instance of the component being disposed.
+     */
+    dispose?(component: ComponentCursor<ComponentSchema, Data, Shared>): void;
+};

package/Components/ComponentArray.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from "../Util/Observable";
+import { SchemaArray } from "../Schema/SchemaArray";
+import { ComponentRegisterData } from "./Component.types";
+import { Graph } from "../Graphs/Graph";
+type ComponentObserverData = [type: number, index: number];
+declare class ComponentArrayObservers {
+    componentAdded: Observable<ComponentObserverData>;
+    componentRemoved: Observable<ComponentObserverData>;
+    nodeAdded: Observable<number>;
+    nodeRemoved: Observable<number>;
+}
+export declare class ComponentArray {
+    graph: Graph;
+    numberTypeId: number;
+    _freeSlots: number[];
+    _node: number[];
+    _disposed: boolean[];
+    _data: any[];
+    schemaArray: SchemaArray;
+    proto: ComponentRegisterData;
+    observers: ComponentArrayObservers;
+    private _nodeCursor;
+    private _componentCursor;
+    constructor(graph: Graph, numberTypeId: number);
+    addComponent(node: number, schema: any | null, schemaView: string | null): number;
+    removeComponent(index: number): number | null;
+    update(): void;
+    init(index: number): boolean;
+}
+export {};

package/Components/ComponentArray.js

@@ -0,0 +1,82 @@
+import { Observable } from "../Util/Observable";
+import { NCSRegister } from "../Register/NCSRegister";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { ComponentCursor } from "./ComponentCursor";
+const componentObserverData = [0, 0];
+class ComponentArrayObservers {
+    componentAdded = new Observable();
+    componentRemoved = new Observable();
+    nodeAdded = new Observable();
+    nodeRemoved = new Observable();
+}
+export class ComponentArray {
+    graph;
+    numberTypeId;
+    _freeSlots = [];
+    _node = [];
+    _disposed = [];
+    _data = [];
+    schemaArray;
+    proto;
+    observers = new ComponentArrayObservers();
+    _nodeCursor;
+    _componentCursor;
+    constructor(graph, numberTypeId) {
+        this.graph = graph;
+        this.numberTypeId = numberTypeId;
+        const proto = NCSRegister.components.get(NCSRegister.components.idPalette.getStringId(numberTypeId));
+        if (proto.schema)
+            this.schemaArray = proto.schema.array;
+        this.proto = proto;
+        this._nodeCursor = NodeCursor.Get();
+        this._componentCursor = ComponentCursor.Get();
+    }
+    addComponent(node, schema, schemaView) {
+        let slot = this._freeSlots.length
+            ? this._freeSlots.shift()
+            : this._node.length;
+        this._node[slot] = node;
+        this._disposed[slot] = false;
+        if (this.schemaArray)
+            this.schemaArray.setData(slot, schema, schemaView);
+        componentObserverData[0] = this.numberTypeId;
+        componentObserverData[1] = slot;
+        this.observers.componentAdded.notify(componentObserverData);
+        return slot;
+    }
+    removeComponent(index) {
+        if (this._node[index] === undefined)
+            return null;
+        componentObserverData[0] = this.numberTypeId;
+        componentObserverData[1] = index;
+        this.observers.componentRemoved.notify(componentObserverData);
+        this.observers.nodeRemoved.notify(this._node[index]);
+        this._freeSlots.push(index);
+        const nodeIndex = this._node[index];
+        this._disposed[index] = true;
+        this._data[index] = undefined;
+        this._node[index] = -1;
+        if (this.schemaArray)
+            this.schemaArray.removeData(index);
+        return nodeIndex;
+    }
+    update() {
+        const update = this.proto.update;
+        if (!update)
+            return;
+        for (let i = 0; i < this._disposed.length; i++) {
+            if (this._disposed[i])
+                continue;
+            this._componentCursor.setInstance(this._nodeCursor.setNode(this.graph, this._node[i]), this.numberTypeId, i);
+            update(this._componentCursor);
+        }
+    }
+    init(index) {
+        const init = this.proto.init;
+        if (!init)
+            return false;
+        this._componentCursor.setInstance(this._nodeCursor.setNode(this.graph, this._node[index]), this.numberTypeId, index);
+        init(this._componentCursor);
+        return false;
+    }
+}

package/Components/ComponentCursor.d.ts

@@ -0,0 +1,27 @@
+import { ComponentRegisterData } from "./Component.types";
+import { SchemaCursor } from "../Schema/Schema.types";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { ComponentArray } from "./ComponentArray";
+export declare class ComponentCursor<ComponentSchema extends object = {}, Data extends any = any, Shared extends any = any> {
+    static Get(): ComponentCursor<{}, any, any>;
+    static Retrun(cursor: ComponentCursor): boolean;
+    get index(): number;
+    get type(): string;
+    get shared(): Shared;
+    schema: SchemaCursor<ComponentSchema>;
+    get data(): Data;
+    set data(data: Data);
+    node: NodeCursor;
+    arrays: ComponentArray;
+    __proto: ComponentRegisterData<ComponentSchema, Data, Shared>;
+    get typeId(): number;
+    private _index;
+    private _type;
+    private constructor();
+    setInstance(node: NodeCursor, type: number, index: number): this;
+    get isDisposed(): boolean;
+    dispose(): void;
+    returnCursor(): boolean;
+    cloneCursor(cursor?: ComponentCursor, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+    update(): void;
+}

package/Components/ComponentCursor.js

@@ -0,0 +1,72 @@
+import { NCSRegister } from "../Register/NCSRegister";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { NCSPools } from "../Pools/NCSPools";
+export class ComponentCursor {
+    static Get() {
+        const cursor = NCSPools.componentCursor.get();
+        if (!cursor)
+            return new ComponentCursor();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        return NCSPools.componentCursor.addItem(cursor);
+    }
+    get index() {
+        return this._index;
+    }
+    get type() {
+        return NCSRegister.components.idPalette.getStringId(this._type);
+    }
+    get shared() {
+        return this.__proto.shared;
+    }
+    schema;
+    get data() {
+        return this.arrays._data[this._index];
+    }
+    set data(data) {
+        this.arrays._data[this._index] = data;
+    }
+    node;
+    arrays;
+    __proto;
+    get typeId() {
+        return this._type;
+    }
+    _index = 0;
+    _type = 0;
+    constructor() { }
+    setInstance(node, type, index) {
+        this._index = index;
+        this._type = type;
+        this.node = node;
+        this.__proto = NCSRegister.components.items[this._type];
+        this.arrays = node.graph._components[type];
+        if (this.arrays?.schemaArray?._data[index] !== undefined) {
+            this.schema = this.arrays.schemaArray.createViewCursor(index);
+            this.schema.setInstance(index);
+        }
+        return this;
+    }
+    get isDisposed() {
+        return this.arrays._disposed[this._index];
+    }
+    dispose() {
+        if (this.__proto.dispose)
+            this.__proto.dispose(this);
+        this.arrays.removeComponent(this._index);
+    }
+    returnCursor() {
+        return ComponentCursor.Retrun(this);
+    }
+    cloneCursor(cursor, nodeCursor) {
+        const newCursor = cursor || ComponentCursor.Get();
+        const newNodeCursor = nodeCursor || NodeCursor.Get();
+        newNodeCursor.setNode(this.node.graph, this.node.index);
+        newCursor.setInstance(newNodeCursor, this.typeId, this._index);
+        return newCursor;
+    }
+    update() {
+        this.__proto.update && this.__proto.update(this);
+    }
+}

package/Contexts/Context.types.d.ts

@@ -0,0 +1,76 @@
+import { RecursivePartial } from "../Util/Util.types";
+import { Schema } from "../Schema/Schema";
+/**
+ * Interface representing the meta data of a context.
+ */
+export interface ContextMetaData {
+    name: string;
+    [key: string]: any;
+}
+/**
+ * Interface representing the state data of a context.
+ */
+export interface ContextStateData {
+    [key: string]: any;
+}
+/**
+ * Type representing the data of a context.
+ *
+ */
+export type SerializedContextData<Schema extends Record<string, any> = {}> = {
+    /**
+     * The type of the context.
+     */
+    type: string;
+    /**
+     * The schema of the context.
+     */
+    schema: Schema;
+    /**
+     * The schema view id  of the component.
+     */
+    schemaViewId: string | null;
+};
+export type CreateContextData<Schema extends Record<string, any> = {}, Data extends Record<string, any> = {}> = [
+    /**
+     * The type of the context.
+     */
+    type: string,
+    /**
+     * The schema of the context.
+     */
+    schema: RecursivePartial<Schema> | null,
+    /**
+     * The schema view id  of the component.
+     */
+    schemaViewId: string | null,
+    /**
+     * The runtime data of the context.
+     */
+    data: Data | null
+];
+/**
+ * Type representing the data required to register a context.
+ *
+ * Used for serlization and creation.
+ * @template Data - The runtime data of the context.
+ */
+export type ContextRegisterData<ContextSchema extends Record<string, any> = {}, Data extends Record<string, any> = {}> = {
+    /**
+     * The type of the context.
+     */
+    type: string;
+    /**
+     * The schema used to create an editable version of the component.
+     * For the actual ComponentInstance the schema is created into an object.
+     */
+    schema?: Schema<ContextSchema>;
+    /**
+     * The runtime data of the context.
+     */
+    data?: Data;
+    /**
+     * The shared meta data of all contexts.
+     */
+    meta?: ContextMetaData;
+};

package/Contexts/ContextArray.d.ts

@@ -0,0 +1,14 @@
+import { ContextStateData } from "./Context.types";
+import { SchemaArray } from "../Schema/SchemaArray";
+export declare class ContextArray {
+    _freeSlots: number[];
+    _type: number[];
+    _node: number[][];
+    _state: ContextStateData[];
+    _disposed: boolean[];
+    _data: any[];
+    schemaArray: SchemaArray[];
+    numberTypeId: number;
+    addContext(type: number, node: number[], state: ContextStateData, schema: any | null, data?: any | null): number;
+    removeContext(index: number): number[] | null;
+}

package/Contexts/ContextArray.js

@@ -0,0 +1,47 @@
+import { NCSRegister } from "../Register/NCSRegister";
+export class ContextArray {
+    _freeSlots = [];
+    _type = [];
+    _node = [];
+    _state = [];
+    _disposed = [];
+    _data = [];
+    schemaArray;
+    numberTypeId;
+    addContext(type, node, state, schema, data = null) {
+        let slot = this._freeSlots.length
+            ? this._freeSlots.shift()
+            : this._node.length;
+        const contextSchema = NCSRegister.contexts.get(type).schema;
+        if (contextSchema) {
+            let schemaArray = this.schemaArray[type];
+            if (!schemaArray) {
+                schemaArray = contextSchema.array;
+                this.schemaArray[type] = schemaArray;
+            }
+            schemaArray.setData(slot, schema);
+        }
+        this._type[slot] = type;
+        this._node[slot] = node;
+        this._state[slot] = state;
+        this._disposed[slot] = false;
+        data && (this._data[slot] = data);
+        return slot;
+    }
+    removeContext(index) {
+        if (this._node[index] === undefined)
+            return null;
+        this._freeSlots.push(index);
+        const data = this._node[index];
+        this._node[index] = [];
+        this._state[index] = -1;
+        this._disposed[index] = true;
+        let schemaArray = this.schemaArray[this._type[index]];
+        this._type[index] = -1;
+        if (schemaArray) {
+            schemaArray.removeData(index);
+        }
+        this._data[index] = undefined;
+        return data;
+    }
+}

package/Contexts/ContextCursor.d.ts

@@ -0,0 +1,24 @@
+import { ContextRegisterData } from "./Context.types";
+import { ContextArray } from "./ContextArray";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { SchemaCursor } from "../Schema/Schema.types";
+import { Graph } from "../Graphs/Graph";
+export declare class ContextCursor<ContextSchema extends {} = {}, Data extends {} = {}> {
+    static Get(): ContextCursor<{}, {}>;
+    static Retrun(cursor: ContextCursor): boolean;
+    proto: ContextRegisterData<ContextSchema, Data>;
+    _index: number;
+    _type: number;
+    get index(): number;
+    get data(): Data;
+    set data(data: Data);
+    schema: SchemaCursor<ContextSchema>;
+    get nodes(): number[];
+    get type(): string;
+    private _graph;
+    get graph(): Graph;
+    arrays: ContextArray;
+    private constructor();
+    setContext(node: NodeCursor, index: number): void;
+    dispose(): void;
+}

package/Contexts/ContextCursor.js

@@ -0,0 +1,47 @@
+import { NCSRegister } from "../Register/NCSRegister";
+import { NCSPools } from "../Pools/NCSPools";
+export class ContextCursor {
+    static Get() {
+        const cursor = NCSPools.contextCursor.get();
+        if (!cursor)
+            return new ContextCursor();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        return NCSPools.contextCursor.addItem(cursor);
+    }
+    proto;
+    _index = 0;
+    _type = 0;
+    get index() {
+        return this._index;
+    }
+    get data() {
+        return this.arrays._data[this._index];
+    }
+    set data(data) {
+        this.arrays._data[this._index] = data;
+    }
+    schema;
+    get nodes() {
+        return this.arrays._node[this._index];
+    }
+    get type() {
+        return NCSRegister.contexts.idPalette.getStringId(this.arrays._type[this._index]);
+    }
+    _graph;
+    get graph() {
+        return this._graph;
+    }
+    arrays;
+    constructor() { }
+    setContext(node, index) {
+        this._index = index;
+        this.arrays = node.graph._contexts;
+        this._graph = node.graph;
+        this._type = this.arrays._type[index];
+    }
+    dispose() {
+        this.arrays.removeContext(this._index);
+    }
+}

package/Data/SerializedData.types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Type representing the data of a component.
+ *
+ * @template ComponentSchema - The ComponentSchema of the component.
+ */
+export type SerializedComponentData<ComponentSchema extends object = any> = {
+    /**
+     * The type of the component.
+     */
+    type: string;
+    /**
+     * The ComponentSchema of the component.
+     */
+    schema?: ComponentSchema;
+    schemaViewId?: string;
+};
+/**
+ * Type representing the data of a node.
+ *
+ * Used for serlization and creation.
+ */
+export type SerializedNodeData = {
+    /**
+     * The unique 128 bit identifier of the node.
+     *
+     */
+    id?: string;
+    /**
+     * The name of the node.
+     */
+    name: string;
+    /**
+     * The components of the node.
+     */
+    components?: SerializedComponentData[];
+    /**
+     * The tags of the node.
+     */
+    tags?: string[];
+    /**
+     * The children nodes of the node.
+     */
+    children?: SerializedNodeData[];
+};

package/Data/deserializeComponent.d.ts

@@ -0,0 +1,3 @@
+import { CreateComponentData } from "../Components/Component.types";
+import { SerializedComponentData } from "./SerializedData.types";
+export declare function deserializeComponentData(data: SerializedComponentData): CreateComponentData;

package/Data/deserializeComponent.js

@@ -0,0 +1,3 @@
+export function deserializeComponentData(data) {
+    return [data.type, data.schema || null, data.schemaViewId || null, null];
+}

package/Data/deserializeNode.d.ts

@@ -0,0 +1,3 @@
+import { CreateNodeData } from "../Nodes/Node.types";
+import { SerializedNodeData } from "./SerializedData.types";
+export declare function deserializeNodeData(data: SerializedNodeData): CreateNodeData;

package/Data/deserializeNode.js

@@ -0,0 +1,34 @@
+import { NodeId } from "../Nodes/NodeId";
+import { deserializeComponentData } from "./deserializeComponent";
+import { NCSRegister } from "../Register/NCSRegister";
+export function deserializeNodeData(data) {
+    let components = null;
+    if (data.components) {
+        components = [];
+        for (let i = 0; i < data.components.length; i++) {
+            const comp = data.components[i];
+            components.push(deserializeComponentData(comp));
+        }
+    }
+    let tags = null;
+    if (data.tags) {
+        tags = [];
+        for (let i = 0; i < data.tags.length; i++) {
+            tags.push(NCSRegister.tags.idPalette.getNumberId(data.tags[i]));
+        }
+    }
+    let children = null;
+    if (data.children) {
+        children = [];
+        for (let i = 0; i < data.children.length; i++) {
+            children.push(deserializeNodeData(data.children[i]));
+        }
+    }
+    return [
+        data.id ? NodeId.FromString(data.id) : null,
+        data.name,
+        components,
+        tags,
+        children,
+    ];
+}

package/Data/serializeComponent.d.ts

@@ -0,0 +1,7 @@
+import { CreateComponentData } from "../Components/Component.types";
+import { ComponentCursor } from "../Components/ComponentCursor";
+import { SerializedComponentData } from "./SerializedData.types";
+export declare function serializeComponentData(data: CreateComponentData): SerializedComponentData;
+export declare function serializeComponent(component: ComponentCursor): SerializedComponentData;
+export declare function copyComponent(component: ComponentCursor): CreateComponentData;
+export declare function createRemoteComponent(component: ComponentCursor): CreateComponentData;

package/Data/serializeComponent.js

@@ -0,0 +1,36 @@
+import { NCSRegister } from "../Register/NCSRegister";
+export function serializeComponentData(data) {
+    const component = NCSRegister.components.get(data[0]);
+    return {
+        type: component.type,
+        ...(data[1] ? { schema: data[1] } : {}),
+        ...(data[2] && data[2] !== "default" ? { schemaViewId: data[2] } : {}),
+    };
+}
+export function serializeComponent(component) {
+    return {
+        type: component.type,
+        ...(component.schema ? { schema: component.schema.toJSON() } : {}),
+        ...(component.schema?.__view && component.schema?.__view.id !== "default"
+            ? { schemaViewId: component.schema.__view.id }
+            : {}),
+    };
+}
+export function copyComponent(component) {
+    return [
+        component.type,
+        component.schema ? component.schema.toJSON() : null,
+        component.schema ? component.schema.__view.id : null,
+        null,
+    ];
+}
+export function createRemoteComponent(component) {
+    return [
+        component.type,
+        component.schema
+            ? component.schema.__view.toRemote(component.schema)
+            : null,
+        component.schema ? component.schema.__view.id : null,
+        true,
+    ];
+}

package/Data/serializeNode.d.ts

@@ -0,0 +1,13 @@
+import { CreateNodeData } from "../Nodes/Node.types";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { SerializedNodeData } from "./SerializedData.types";
+export declare function serializeNodeData(data: CreateNodeData): SerializedNodeData;
+/** Serialize the node data as is for storage*/
+export declare function serializeNode(node: NodeCursor): SerializedNodeData;
+/** Copy the node data as is */
+export declare function copyNode(node: NodeCursor): CreateNodeData;
+/** Clone the node data and create new ids if needed. */
+export declare function cloneNode(node: NodeCursor): SerializedNodeData;
+export declare function createRemoteNode(node: NodeCursor, includeChildren?: boolean, includedComponents?: {
+    type: string;
+}[]): CreateNodeData;