@amodx/ncs 0.0.1

package/Traits/TraitInstance.js

@@ -0,0 +1,115 @@
+import { ComponentInstance } from "../Components/ComponentInstance";
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { TraintContainer } from "./TraitContainer";
+import { TraitObservers } from "./TraitObservers";
+import { TraitPipelines } from "./TraitPipelines";
+export class TraitInstance {
+    type;
+    schema;
+    data;
+    logic;
+    state;
+    _shared;
+    get shared() {
+        return this._shared;
+    }
+    _traits;
+    get traits() {
+        if (!this._traits) {
+            this._traits = new TraintContainer(this);
+        }
+        return this._traits;
+    }
+    get hasTraits() {
+        return Boolean(this._traits);
+    }
+    _observers;
+    get observers() {
+        if (!this._observers) {
+            this._observers = new TraitObservers();
+        }
+        return this._observers;
+    }
+    get hasObservers() {
+        return Boolean(this._observers);
+    }
+    _pipelines;
+    get pipelines() {
+        if (!this._pipelines) {
+            this._pipelines = new TraitPipelines();
+        }
+        return this._pipelines;
+    }
+    get hasPipelines() {
+        return Boolean(this._pipelines);
+    }
+    parent;
+    traitProotype;
+    getNode() {
+        let node = this.parent;
+        while (!(node instanceof NodeInstance)) {
+            if (node instanceof ComponentInstance) {
+                node = node.node;
+                break;
+            }
+            if (node instanceof TraitInstance) {
+                node = node.parent;
+            }
+        }
+        return node;
+    }
+    async init() {
+        if (!this.traitProotype.data.init)
+            return;
+        await this.traitProotype.data.init(this);
+    }
+    _disposed = false;
+    isDisposed() {
+        return this._disposed;
+    }
+    async dispose() {
+        this.hasPipelines &&
+            this.pipelines.isDisposedSet() &&
+            this.pipelines.disposed.pipe(this);
+        this.hasObservers &&
+            this.observers.isDisposedSet() &&
+            this.observers.disposed.notify();
+        if (this.traitProotype.data.dispose)
+            await this.traitProotype.data.dispose(this);
+        this._disposed = true;
+        if (this.hasTraits)
+            await this.traits.dispose();
+        this.traitProotype.destory(this);
+        delete this._traits;
+        delete this._observers;
+        delete this._pipelines;
+    }
+    copy() {
+        const data = {
+            schema: this.schema?.getSchema
+                ? this.schema.getSchema().store()
+                : {},
+            type: this.type,
+            state: this.state,
+            traits: (this.hasTraits && this.traits.traits.map((_) => _.toJSON())) || [],
+        };
+        return ((this.hasPipelines &&
+            this.pipelines.isCopySet() &&
+            this.pipelines.copy.pipe(data)) ||
+            data);
+    }
+    toJSON() {
+        const data = {
+            schema: this.schema?.getSchema
+                ? this.schema.getSchema().store()
+                : {},
+            type: this.type,
+            state: this.state,
+            traits: (this.hasTraits && this.traits.traits.map((_) => _.toJSON())) || [],
+        };
+        return ((this.hasPipelines &&
+            this.pipelines.isCopySet() &&
+            this.pipelines.copy.pipe(data)) ||
+            data);
+    }
+}

package/Traits/TraitInstanceMap.d.ts

@@ -0,0 +1,7 @@
+import { TraitInstance } from "./TraitInstance";
+import { ItemGraphMap } from "../Maps/ItemGraphMap";
+export declare class TraitInstanceMap {
+    private static types;
+    static registerTrait(type: string): ItemGraphMap<any>;
+    static getMap(type: string): ItemGraphMap<TraitInstance<any, any, any, any>>;
+}

package/Traits/TraitInstanceMap.js

@@ -0,0 +1,15 @@
+import { ItemGraphMap } from "../Maps/ItemGraphMap";
+export class TraitInstanceMap {
+    static types = new Map();
+    static registerTrait(type) {
+        const map = new ItemGraphMap();
+        this.types.set(type, map);
+        return map;
+    }
+    static getMap(type) {
+        const map = this.types.get(type);
+        if (!map)
+            throw new Error(`Map for trait ${type} does not exist`);
+        return map;
+    }
+}

package/Traits/TraitObservers.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "@amodx/core/Observers";
+export interface TraitObservers {
+}
+export declare class TraitObservers {
+    private _disposed?;
+    get disposed(): Observable<void>;
+    isDisposedSet(): boolean;
+}

package/Traits/TraitObservers.js

@@ -0,0 +1,13 @@
+import { Observable } from "@amodx/core/Observers";
+export class TraitObservers {
+    _disposed;
+    get disposed() {
+        if (!this._disposed) {
+            this._disposed = new Observable();
+        }
+        return this._disposed;
+    }
+    isDisposedSet() {
+        return !!this._disposed;
+    }
+}

package/Traits/TraitPipelines.d.ts

@@ -0,0 +1,16 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+import { TraitInstance } from "./TraitInstance";
+import { TraitData } from "./TraitData";
+export interface TraitPipelines {
+}
+export declare class TraitPipelines<TraitSchema extends object = {}> {
+    private _disposed?;
+    private _toJSON?;
+    private _copy?;
+    get disposed(): Pipeline<TraitInstance<TraitSchema>>;
+    get toJSON(): Pipeline<TraitData<TraitSchema>>;
+    get copy(): Pipeline<TraitData<TraitSchema>>;
+    isDisposedSet(): boolean;
+    isToJSONSet(): boolean;
+    isCopySet(): boolean;
+}

package/Traits/TraitPipelines.js

@@ -0,0 +1,33 @@
+import { Pipeline } from "@amodx/core/Pipelines";
+export class TraitPipelines {
+    _disposed;
+    _toJSON;
+    _copy;
+    get disposed() {
+        if (!this._disposed) {
+            this._disposed = new Pipeline();
+        }
+        return this._disposed;
+    }
+    get toJSON() {
+        if (!this._toJSON) {
+            this._toJSON = new Pipeline();
+        }
+        return this._toJSON;
+    }
+    get copy() {
+        if (!this._copy) {
+            this._copy = new Pipeline();
+        }
+        return this._copy;
+    }
+    isDisposedSet() {
+        return !!this._disposed;
+    }
+    isToJSONSet() {
+        return !!this._toJSON;
+    }
+    isCopySet() {
+        return !!this._copy;
+    }
+}

package/Traits/TraitPrototype.d.ts

@@ -0,0 +1,16 @@
+import { ObjectSchemaInstance, Schema } from "@amodx/schemas";
+import { TraitData, TraitRegisterData } from "./TraitData";
+import { TraitInstance } from "./TraitInstance";
+import { ItemPool } from "../Pools/ItemPool";
+export declare class TraitPrototype<TraitSchema extends object = {}, Data extends Record<string, any> = {}, Logic extends Record<string, any> = {}, Shared extends Record<string, any> = {}> {
+    data: TraitRegisterData<TraitSchema, Data, Logic, Shared>;
+    schemaController: Schema<TraitSchema> | null;
+    baseContextSchema: TraitSchema;
+    pool: ItemPool<TraitInstance<TraitSchema, Data, Logic, Shared>>;
+    constructor(data: TraitRegisterData<TraitSchema, Data, Logic, Shared>);
+    getSchema(overrides: Partial<TraitSchema>): ObjectSchemaInstance<TraitSchema>;
+    private getPooled;
+    private return;
+    create(parent: TraitInstance["parent"], data: TraitData): TraitInstance<TraitSchema, Data, Logic, Shared>;
+    destory(instance: TraitInstance<TraitSchema, Data, Logic, Shared>): void;
+}

package/Traits/TraitPrototype.js

@@ -0,0 +1,74 @@
+import { Schema } from "@amodx/schemas";
+import { TraitInstance } from "./TraitInstance";
+import { TraitInstanceMap } from "./TraitInstanceMap";
+import { ItemPool } from "../Pools/ItemPool";
+export class TraitPrototype {
+    data;
+    schemaController;
+    baseContextSchema;
+    pool = new ItemPool();
+    constructor(data) {
+        this.data = data;
+        this.schemaController =
+            Array.isArray(data.schema) && data.schema.length
+                ? Schema.Create(...data.schema)
+                : null;
+        this.baseContextSchema = (this.schemaController ? this.schemaController.createData() : {});
+        this.pool.maxSize = data.pool?.maxSize || 100;
+    }
+    getSchema(overrides) {
+        if (!this.schemaController)
+            return structuredClone(this.baseContextSchema);
+        return this.schemaController.instantiate(overrides);
+    }
+    getPooled() {
+        let comp = null;
+        if (this.data.pool?.maxSize) {
+            comp = this.pool.get();
+        }
+        return comp || new TraitInstance();
+    }
+    return(component) {
+        if (this.data.pool?.maxSize) {
+            return this.pool.addItem(component);
+        }
+        return null;
+    }
+    create(parent, data) {
+        const instance = this.getPooled();
+        instance.parent = parent;
+        if (this.data.schema && !instance.schema) {
+            instance.schema = this.getSchema(data.schema);
+        }
+        if (this.data.schema && instance.schema) {
+            instance.schema.getSchema().loadIn(this.data.schema);
+        }
+        if (this.data.logic) {
+            instance.logic = this.data.logic
+                ? typeof this.data.logic == "function"
+                    ? this.data.logic(instance)
+                    : structuredClone(this.data.logic)
+                : {};
+        }
+        if (this.data.data) {
+            instance.data = this.data.data
+                ? typeof this.data.data == "function"
+                    ? this.data.data(instance)
+                    : structuredClone(this.data.data)
+                : {};
+        }
+        if (data.state) {
+            instance.state = structuredClone(data.state);
+        }
+        const node = instance.getNode();
+        const map = TraitInstanceMap.getMap(data.type);
+        map.addNode(node, instance);
+        return instance;
+    }
+    destory(instance) {
+        const node = instance.getNode();
+        const map = TraitInstanceMap.getMap(instance.type);
+        map.removeNode(node, instance);
+        this.return(instance);
+    }
+}

package/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./NCS";
+export * from "./Graphs/Graph";
+export * from "./Components/ComponentData";
+export * from "./Components/ComponentInstance";
+export * from "./Traits/TraitData";
+export * from "./Traits/TraitInstance";
+export * from "./Nodes/NodeData";
+export * from "./Nodes/NodeInstance";

package/index.js

@@ -0,0 +1,8 @@
+export * from "./NCS";
+export * from "./Graphs/Graph";
+export * from "./Components/ComponentData";
+export * from "./Components/ComponentInstance";
+export * from "./Traits/TraitData";
+export * from "./Traits/TraitInstance";
+export * from "./Nodes/NodeData";
+export * from "./Nodes/NodeInstance";

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@amodx/ncs",
+  "version": "0.0.01",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "description": "NCS (Node Component System) is a library for the base of any NCS/ECS system.",
+  "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"
+  }
+}