@amodx/ncs 0.0.1 → 0.0.2

package/Tags/TagPrototype.js

@@ -1,34 +0,0 @@
-import { TagInstance } from "./TagInstance";
-import { ItemPool } from "../Pools/ItemPool";
-import { TagInstanceMap } from "./TagInstanceMap";
-export class TagPrototype {
-    data;
-    tag;
-    pool = new ItemPool(1000);
-    constructor(data, tag) {
-        this.data = data;
-        this.tag = tag;
-    }
-    getPooled() {
-        let tag = null;
-        tag = this.pool.get();
-        return tag || new TagInstance();
-    }
-    return(tag) {
-        this.pool.addItem(tag);
-    }
-    create(node, data) {
-        const instance = this.getPooled();
-        instance.node = node;
-        instance.tag = this.tag;
-        instance.tagPrototype = this;
-        const map = TagInstanceMap.getMap(data.id);
-        map.addNode(node, instance);
-        return instance;
-    }
-    destory(tag) {
-        const map = TagInstanceMap.getMap(tag.id);
-        map.removeNode(tag.node, tag);
-        this.return(tag);
-    }
-}

package/Traits/TraitContaienrObservers.d.ts

@@ -1,15 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-import { TraitInstance } from "Traits/TraitInstance";
-export interface TraitContainerObservers {
-}
-export declare class TraitContainerObservers {
-    private _traitAdded?;
-    private _traitRemoved?;
-    private _traitsUpdated?;
-    get traitAdded(): Observable<TraitInstance>;
-    get traitRemoved(): Observable<TraitInstance>;
-    get traitsUpdated(): Observable<void>;
-    isTraitAddedSet(): boolean;
-    isTraitRemovedSet(): boolean;
-    isTraitsUpdatedSet(): boolean;
-}

package/Traits/TraitContaienrObservers.js

@@ -1,33 +0,0 @@
-import { Observable } from "@amodx/core/Observers";
-export class TraitContainerObservers {
-    _traitAdded;
-    _traitRemoved;
-    _traitsUpdated;
-    get traitAdded() {
-        if (!this._traitAdded) {
-            this._traitAdded = new Observable();
-        }
-        return this._traitAdded;
-    }
-    get traitRemoved() {
-        if (!this._traitRemoved) {
-            this._traitRemoved = new Observable();
-        }
-        return this._traitRemoved;
-    }
-    get traitsUpdated() {
-        if (!this._traitsUpdated) {
-            this._traitsUpdated = new Observable();
-        }
-        return this._traitsUpdated;
-    }
-    isTraitAddedSet() {
-        return !!this._traitAdded;
-    }
-    isTraitRemovedSet() {
-        return !!this._traitRemoved;
-    }
-    isTraitsUpdatedSet() {
-        return !!this._traitsUpdated;
-    }
-}

package/Traits/TraitContainer.d.ts

@@ -1,22 +0,0 @@
-import { TraitInstance } from "./TraitInstance";
-import { ComponentInstance } from "../Components/ComponentInstance";
-import { TraitData } from "./TraitData";
-import { TraitContainerObservers } from "./TraitContaienrObservers";
-export declare class TraintContainer {
-    parent: ComponentInstance<any, any, any> | TraitInstance;
-    private _observers?;
-    get observers(): TraitContainerObservers;
-    get hasObservers(): boolean;
-    traits: TraitInstance[];
-    constructor(parent: ComponentInstance<any, any, any> | TraitInstance);
-    traverseTraits(): Generator<any>;
-    dispose(): Promise<void>;
-    initAllTraits(): Promise<void>;
-    add(trait: TraitData): Promise<TraitInstance<any, any, any, any>>;
-    addTraits(...traits: TraitData[]): Promise<TraitInstance<any, any, any, any>[]>;
-    removeByIndex(index: number): Promise<boolean>;
-    remove(type: string): Promise<boolean>;
-    get(type: string): TraitInstance<any, any, any, any> | null;
-    getAll(type: string): TraitInstance<any, any, any, any>[];
-    removeAll(type: string): Promise<TraitInstance<any, any, any, any>[]>;
-}

package/Traits/TraitContainer.js

@@ -1,114 +0,0 @@
-import { TraitContainerObservers } from "./TraitContaienrObservers";
-import { NCSRegister } from "../Register/NCSRegister";
-export class TraintContainer {
-    parent;
-    _observers;
-    get observers() {
-        if (!this._observers) {
-            this._observers = new TraitContainerObservers();
-        }
-        return this._observers;
-    }
-    get hasObservers() {
-        return Boolean(this._observers);
-    }
-    traits = [];
-    constructor(parent) {
-        this.parent = parent;
-    }
-    *traverseTraits() {
-        const children = [...this.traits];
-        while (children.length) {
-            const child = children.shift();
-            yield child;
-            if (child.traits.traits.length)
-                children.push(...child.traits.traits);
-        }
-    }
-    async dispose() {
-        for (const child of this.traits) {
-            child.dispose();
-        }
-    }
-    async initAllTraits() {
-        for (const trait of this.traits) {
-            await trait.init();
-        }
-    }
-    async add(trait) {
-        const traitType = NCSRegister.traits.get(trait.type, trait.namespace || "main");
-        const newTrait = traitType.create(this.parent, trait);
-        this.traits.push(newTrait);
-        await newTrait.init();
-        if (trait.traits?.length) {
-            newTrait.traits.addTraits(...trait.traits);
-        }
-        this.hasObservers &&
-            this.observers.isTraitAddedSet() &&
-            this.observers.traitAdded.notify(newTrait);
-        this.hasObservers &&
-            this.observers.isTraitsUpdatedSet() &&
-            this.observers.traitsUpdated.notify();
-        return newTrait;
-    }
-    async addTraits(...traits) {
-        const newTraits = [];
-        for (const trait of traits) {
-            const traitType = NCSRegister.traits.get(trait.type, trait.namespace || "main");
-            const newTrait = traitType.create(this.parent, trait);
-            this.traits.push(newTrait);
-            newTraits.push(newTrait);
-            await newTrait.init();
-            if (trait.traits?.length) {
-                newTrait.traits.addTraits(...trait.traits);
-            }
-            this.hasObservers &&
-                this.observers.isTraitAddedSet() &&
-                this.observers.traitAdded.notify(newTrait);
-        }
-        this.hasObservers &&
-            this.observers.isTraitsUpdatedSet() &&
-            this.observers.traitsUpdated.notify();
-        return newTraits;
-    }
-    async removeByIndex(index) {
-        const trait = this.traits[index];
-        if (trait) {
-            const child = this.traits.splice(index, 1)[0];
-            this.hasObservers &&
-                this.observers.isTraitRemovedSet() &&
-                this.observers.traitRemoved.notify(child);
-            this.hasObservers &&
-                this.observers.isTraitsUpdatedSet() &&
-                this.observers.traitsUpdated.notify();
-            await trait.dispose();
-            return true;
-        }
-        return false;
-    }
-    remove(type) {
-        return this.removeByIndex(this.traits.findIndex((_) => _.type == type));
-    }
-    get(type) {
-        return this.traits.find((_) => _.type == type) || null;
-    }
-    getAll(type) {
-        return this.traits.filter((_) => _.type == type);
-    }
-    async removeAll(type) {
-        const filtered = this.getAll(type);
-        for (const trait of filtered) {
-            await trait.dispose();
-        }
-        this.traits = this.traits.filter((_) => _.type != type);
-        for (const comp of filtered) {
-            this.hasObservers &&
-                this.observers.isTraitRemovedSet() &&
-                this.observers.traitRemoved.notify(comp);
-        }
-        this.hasObservers &&
-            this.observers.isTraitsUpdatedSet() &&
-            this.observers.traitsUpdated.notify();
-        return filtered;
-    }
-}

package/Traits/TraitData.d.ts

@@ -1,106 +0,0 @@
-import { Property } from "@amodx/schemas";
-import { TraitInstance } from "./TraitInstance";
-/**
- * Interface representing the meta data of a trait.
- */
-export interface TraitMetaData {
-    name: string;
-    [key: string]: any;
-}
-/**
- * Interface representing the pool data of a component.
- */
-export interface TraitPoolData {
-    maxSize: number;
-    [key: string]: any;
-}
-/**
- * Interface representing the state data of a trait.
- */
-export interface TraitStateData {
-    [key: string]: any;
-}
-/**
- * Type representing the data of a trait.
- *
- * @template TraitSchema - The TraitSchema of the trait.
- */
-export type TraitData<TraitSchema extends object = any> = {
-    /**
-     * The type of the trait.
-     */
-    type: string;
-    /**
-     * The namespace of the trait.
-     */
-    namespace?: string;
-    /**
-     * The state data of the trait.
-     */
-    state: TraitStateData;
-    /**
-     * The TraitSchema of the trait.
-     */
-    schema: TraitSchema;
-    /**
-     * The traits associated with the trait.
-     */
-    traits: TraitData[];
-};
-/**
- * Type representing the data required to register a trait.
- *
- * Used for serlization and creation.
- * @template TraitSchema - The schema of the trait.
- * @template Data - The runtime data of the trait.
- * @template Logic - The logic functions of the trait.
- * @template Shared - The shared data of all traits of this type.
- */
-export type TraitRegisterData<TraitSchema extends object = {}, Data extends Record<string, any> = {}, Logic extends Record<string, any> = {}, Shared extends Record<string, any> = {}> = {
-    /**
-     * The type of the trait.
-     */
-    type: string;
-    /**
-     * The namespace of the trait.
-     */
-    namespace?: string;
-    /**
-     * The optional name of the trait.
-     */
-    name?: string;
-    pool?: TraitPoolData;
-    /**
-     * The schema used to create an editable version of the trait.
-     * For the actual TraitInstance the schema is created into an object.
-     */
-    schema?: Property<any, any>[];
-    /**
-     * The logic functions of the trait.
-     */
-    logic?: Logic | ((component: TraitInstance<TraitSchema, Data, Logic, Shared>) => Logic);
-    /**
-     * The runtime data of the trait.
-     */
-    data?: Data | ((component: TraitInstance<TraitSchema, Data, Logic, Shared>) => Data);
-    /**
-     * The shared data of all traits.
-     */
-    shared?: Shared;
-    /**
-     * The shared meta data of all traits.
-     */
-    meta?: TraitMetaData;
-    /**
-     * Optional initialization function for the trait.
-     *
-     * @param component - The instance of the component being initialized.
-     */
-    init?(component: TraitInstance<TraitSchema, Data, Logic>): Promise<void> | void;
-    /**
-     * Optional disposal function for the trait.
-     *
-     * @param component - The instance of the component being disposed.
-     */
-    dispose?(component: TraitInstance<TraitSchema, Data, Logic>): Promise<void> | void;
-};

package/Traits/TraitInstance.d.ts

@@ -1,35 +0,0 @@
-import { TraitData, TraitStateData } from "./TraitData";
-import { ObjectSchemaInstance } from "@amodx/schemas";
-import { ComponentInstance } from "../Components/ComponentInstance";
-import { NodeInstance } from "../Nodes/NodeInstance";
-import { TraintContainer } from "./TraitContainer";
-import { TraitObservers } from "./TraitObservers";
-import { TraitPipelines } from "./TraitPipelines";
-import { TraitPrototype } from "./TraitPrototype";
-export declare class TraitInstance<TraitSchema extends object = {}, Data extends object = {}, Logic extends object = {}, Shared extends object = {}> {
-    type: string;
-    schema: ObjectSchemaInstance<TraitSchema>;
-    data: Data;
-    logic: Logic;
-    state: TraitStateData;
-    private _shared;
-    get shared(): Shared;
-    private _traits?;
-    get traits(): TraintContainer;
-    get hasTraits(): boolean;
-    private _observers?;
-    get observers(): TraitObservers;
-    get hasObservers(): boolean;
-    private _pipelines?;
-    get pipelines(): TraitPipelines<TraitSchema>;
-    get hasPipelines(): boolean;
-    parent: ComponentInstance<any, any, any, any> | TraitInstance<any, any, any, any>;
-    traitProotype: TraitPrototype<TraitSchema, Data, Logic, Shared>;
-    getNode(): NodeInstance;
-    init(): Promise<void>;
-    private _disposed;
-    isDisposed(): boolean;
-    dispose(): Promise<void>;
-    copy(): TraitData;
-    toJSON(): TraitData;
-}

package/Traits/TraitInstance.js

@@ -1,115 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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);
-    }
-}