mftsccs-node 0.2.7 → 0.2.8

package/dist/types/DataStructures/Local/LocalBinaryCharacterTree.d.ts

@@ -1,12 +1,145 @@
+/**
+ * @fileoverview Local Binary Character Tree for managing concepts indexed by character value.
+ * This module provides a specialized binary tree implementation for efficient character-based lookups.
+ * @module DataStructures/Local/LocalBinaryCharacterTree
+ */
 import { LConcept } from "../../DataStructures/Local/LConcept";
 import { LNode } from "./../Local/LNode";
+/**
+ * Binary tree data structure for managing local concepts indexed by character values.
+ *
+ * @remarks
+ * This class implements an AVL tree specifically optimized for character-based lookups.
+ * Unlike LocalBinaryTree which uses numeric IDs, this tree uses character values as keys,
+ * enabling efficient string-based searches with O(log n) complexity.
+ *
+ * @example
+ * ```typescript
+ * const concept = new LConcept(123, "example", 1);
+ * LocalBinaryCharacterTree.addConceptToTree(concept);
+ * const node = LocalBinaryCharacterTree.getNodeFromTree("example");
+ * ```
+ */
 export declare class LocalBinaryCharacterTree {
+    /**
+     * The root node of the character-indexed binary tree.
+     * Null if the tree is empty.
+     */
     static LocalCharacterRoot: LNode | null;
+    /**
+     * Waits for local character data to be loaded into the tree.
+     *
+     * @returns A promise that resolves with "done" when data is loaded, or rejects with "not" after 25 seconds
+     *
+     * @remarks
+     * This method polls the IdentifierFlags.isLocalCharacterLoaded flag every second.
+     * Useful for ensuring data is ready before performing operations on the tree.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await LocalBinaryCharacterTree.waitForDataToLoad();
+     *   console.log("Character data loaded");
+     * } catch (error) {
+     *   console.log("Loading timed out");
+     * }
+     * ```
+     */
     static waitForDataToLoad(): Promise<unknown>;
+    /**
+     * Periodically checks if local character data has been loaded.
+     *
+     * @param resolve - The promise resolve function to call when data is loaded
+     *
+     * @remarks
+     * This method recursively checks the IdentifierFlags.isLocalCharacterLoaded flag every 1000ms.
+     */
     static checkFlag(resolve: any): any;
+    /**
+     * Adds a node to the character-indexed binary tree.
+     *
+     * @param node - The LNode to be added to the tree (keyed by character value)
+     * @returns The root node after insertion
+     *
+     * @remarks
+     * If the tree is empty, the provided node becomes the root.
+     * Otherwise, uses the addCharacterNode method for character-based insertion.
+     *
+     * @example
+     * ```typescript
+     * const node = new LNode("example", concept, null, null);
+     * await LocalBinaryCharacterTree.addNodeToTree(node);
+     * ```
+     */
     static addNodeToTree(node: LNode): Promise<LNode | null>;
+    /**
+     * Creates a node from a concept and adds it to the character tree.
+     *
+     * @param concept - The LConcept object to be added to the tree
+     *
+     * @remarks
+     * Only adds the concept if it has a non-empty characterValue.
+     * The node is keyed by the concept's character value.
+     *
+     * @example
+     * ```typescript
+     * const concept = new LConcept(123, "example", 1);
+     * LocalBinaryCharacterTree.addConceptToTree(concept);
+     * ```
+     */
     static addConceptToTree(concept: LConcept): void;
+    /**
+     * Retrieves a node from the tree by its character value.
+     *
+     * @param value - The character string to search for
+     * @returns The LNode if found, the root node otherwise
+     *
+     * @remarks
+     * Performs a binary search through the tree using the character value as the key.
+     *
+     * @example
+     * ```typescript
+     * const node = LocalBinaryCharacterTree.getNodeFromTree("example");
+     * if (node) {
+     *   console.log("Found concept:", node.value);
+     * }
+     * ```
+     */
     static getNodeFromTree(value: string): LNode | null;
+    /**
+     * Retrieves a node by matching both character value and type ID.
+     *
+     * @param value - The character value to search for
+     * @param typeId - The type ID to match
+     * @returns The matching LNode if found, the root node otherwise
+     *
+     * @remarks
+     * This method searches for a node that matches both the character value and type ID,
+     * useful for finding specific concept variants.
+     *
+     * @example
+     * ```typescript
+     * const node = await LocalBinaryCharacterTree.getCharacterAndTypeFromTree("example", 5);
+     * if (node) {
+     *   console.log("Found matching concept:", node.value);
+     * }
+     * ```
+     */
     static getCharacterAndTypeFromTree(value: string, typeId: number): Promise<LNode | null>;
+    /**
+     * Removes a concept variant from the tree.
+     *
+     * @param character - The character value identifying the node
+     * @param id - The concept ID to remove
+     *
+     * @remarks
+     * This method removes a specific variant from a node while maintaining other variants.
+     * If the node has no remaining variants, the entire node is removed.
+     *
+     * @example
+     * ```typescript
+     * LocalBinaryCharacterTree.removeConceptType("example", 123);
+     * ```
+     */
     static removeConceptType(character: string, id: number): void;
 }

package/dist/types/DataStructures/Local/LocalBinaryTree.d.ts

@@ -1,12 +1,147 @@
+/**
+ * @fileoverview Local Binary Tree data structure for managing local concepts.
+ * This module provides a binary tree implementation for storing and retrieving LConcept objects
+ * using an AVL tree structure for balanced performance.
+ * @module DataStructures/Local/LocalBinaryTree
+ */
 import { LConcept } from "../../DataStructures/Local/LConcept";
 import { LNode } from "./../Local/LNode";
+/**
+ * Binary tree data structure for managing local concepts with efficient lookup by ID.
+ *
+ * @remarks
+ * This class implements a self-balancing binary search tree (AVL tree) for storing local concepts.
+ * It provides O(log n) search, insertion, and deletion operations. The tree is keyed by concept ID
+ * and supports asynchronous data loading with timeout capabilities.
+ *
+ * @example
+ * ```typescript
+ * const concept = new LConcept(123, "example", 1);
+ * LocalBinaryTree.addConceptToTree(concept);
+ * const node = await LocalBinaryTree.getNodeFromTree(123);
+ * ```
+ */
 export declare class LocalBinaryTree {
+    /**
+     * The root node of the binary tree.
+     * Null if the tree is empty.
+     */
     static root: LNode | null;
+    /**
+     * Adds a node to the binary tree.
+     *
+     * @param node - The LNode to be added to the tree
+     * @returns The root node after insertion
+     *
+     * @remarks
+     * If the tree is empty, the provided node becomes the root.
+     * Otherwise, the node is inserted at the appropriate position using the AVL tree algorithm.
+     *
+     * @example
+     * ```typescript
+     * const node = new LNode(123, concept, null, null);
+     * LocalBinaryTree.addNodeToTree(node);
+     * ```
+     */
     static addNodeToTree(node: LNode): LNode | undefined;
+    /**
+     * Creates a node from a concept and adds it to the tree.
+     *
+     * @param concept - The LConcept object to be added to the tree
+     *
+     * @remarks
+     * This is a convenience method that creates an LNode from the concept and adds it to the tree.
+     * The node is keyed by the concept's ID.
+     *
+     * @example
+     * ```typescript
+     * const concept = new LConcept(123, "example", 1);
+     * LocalBinaryTree.addConceptToTree(concept);
+     * ```
+     */
     static addConceptToTree(concept: LConcept): void;
+    /**
+     * Waits for local data to be loaded into the tree.
+     *
+     * @returns A promise that resolves with "done" when data is loaded, or rejects with "not" after 25 seconds
+     *
+     * @remarks
+     * This method polls the IdentifierFlags.isLocalDataLoaded flag every second until it's true.
+     * If data isn't loaded within 25 seconds, the promise is rejected.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await LocalBinaryTree.waitForDataToLoad();
+     *   console.log("Data loaded successfully");
+     * } catch (error) {
+     *   console.log("Data loading timed out");
+     * }
+     * ```
+     */
     static waitForDataToLoad(): Promise<unknown>;
+    /**
+     * Periodically checks if local data has been loaded.
+     *
+     * @param resolve - The promise resolve function to call when data is loaded
+     *
+     * @remarks
+     * This method is called recursively every 1000ms until the data is loaded.
+     * It checks the IdentifierFlags.isLocalDataLoaded flag.
+     */
     static checkFlag(resolve: any): any;
+    /**
+     * Retrieves a node from the tree by its ID.
+     *
+     * @param id - The numeric ID of the node to retrieve
+     * @returns The LNode if found, null otherwise
+     *
+     * @remarks
+     * This method performs a binary search through the tree using the concept ID as the key.
+     * The search has O(log n) time complexity in a balanced tree.
+     *
+     * @example
+     * ```typescript
+     * const node = await LocalBinaryTree.getNodeFromTree(123);
+     * if (node) {
+     *   console.log("Found concept:", node.value);
+     * }
+     * ```
+     */
     static getNodeFromTree(id: number): Promise<LNode | null>;
+    /**
+     * Retrieves a node by matching both character value and type ID.
+     *
+     * @param value - The character value to search for
+     * @param typeId - The type ID to match
+     * @returns The matching LNode if found, the root node otherwise
+     *
+     * @remarks
+     * This method searches for a node that matches both the character value and type ID.
+     * It's useful for finding specific concept variants.
+     *
+     * @example
+     * ```typescript
+     * const node = LocalBinaryTree.getCharacterAndTypeFromTree("example", 5);
+     * if (node) {
+     *   console.log("Found matching concept:", node.value);
+     * }
+     * ```
+     */
     static getCharacterAndTypeFromTree(value: string, typeId: number): LNode | null;
+    /**
+     * Removes a node from the tree by its ID.
+     *
+     * @param id - The numeric ID of the node to remove
+     *
+     * @remarks
+     * This method removes a node from the tree while maintaining the AVL tree balance.
+     * The tree is automatically rebalanced after removal.
+     *
+     * @example
+     * ```typescript
+     * await LocalBinaryTree.removeNodeFromTree(123);
+     * ```
+     */
     static removeNodeFromTree(id: number): Promise<void>;
 }

package/dist/types/DataStructures/Local/LocalBinaryTypeTree.d.ts

@@ -1,13 +1,160 @@
+/**
+ * @fileoverview Local Binary Type Tree for managing concepts indexed by type ID.
+ * This module provides a specialized binary tree for efficient type-based concept lookups and variant retrieval.
+ * @module DataStructures/Local/LocalBinaryTypeTree
+ */
 import { LConcept } from "../../DataStructures/Local/LConcept";
 import { LNode } from "./LNode";
+/**
+ * Binary tree data structure for managing local concepts indexed by type ID.
+ *
+ * @remarks
+ * This class implements an AVL tree optimized for type-based lookups, enabling efficient
+ * retrieval of all concepts of a specific type. It supports variant management, allowing
+ * multiple concepts to share the same type while being stored efficiently.
+ *
+ * @example
+ * ```typescript
+ * const concept = new LConcept(123, "example", 5);
+ * LocalBinaryTypeTree.addConceptToTree(concept);
+ * const variants = LocalBinaryTypeTree.getTypeVariantsFromTree(5);
+ * ```
+ */
 export declare class LocalBinaryTypeTree {
+    /**
+     * The root node of the type-indexed binary tree.
+     * Null if the tree is empty.
+     */
     static LocalTypeRoot: LNode | null;
+    /**
+     * Adds a node to the type-indexed binary tree.
+     *
+     * @param node - The LNode to be added to the tree (keyed by type ID)
+     * @returns The root node after insertion
+     *
+     * @remarks
+     * If the tree is empty, the provided node becomes the root.
+     * Otherwise, uses the addTypeNode method for type-based insertion with variant support.
+     *
+     * @example
+     * ```typescript
+     * const node = new LNode(5, concept, null, null);
+     * await LocalBinaryTypeTree.addNodeToTree(node);
+     * ```
+     */
     static addNodeToTree(node: LNode): Promise<LNode | null>;
+    /**
+     * Creates a node from a concept and adds it to the type tree.
+     *
+     * @param concept - The LConcept object to be added to the tree
+     *
+     * @remarks
+     * Only adds the concept if it has a non-zero typeId.
+     * The node is keyed by the concept's type ID.
+     *
+     * @example
+     * ```typescript
+     * const concept = new LConcept(123, "example", 5);
+     * LocalBinaryTypeTree.addConceptToTree(concept);
+     * ```
+     */
     static addConceptToTree(concept: LConcept): void;
+    /**
+     * Removes a specific concept variant from the tree.
+     *
+     * @param typeId - The type ID identifying the node
+     * @param id - The concept ID to remove
+     *
+     * @remarks
+     * This method removes a specific variant from a node while maintaining other variants.
+     * If the node has no remaining variants, the entire node is removed.
+     *
+     * @example
+     * ```typescript
+     * LocalBinaryTypeTree.removeConceptType(5, 123);
+     * ```
+     */
     static removeConceptType(typeId: number, id: number): void;
+    /**
+     * Retrieves a node from the tree by its type ID.
+     *
+     * @param id - The numeric type ID to search for
+     * @returns The LNode if found, the root node otherwise
+     *
+     * @remarks
+     * Performs a binary search through the tree using the type ID as the key.
+     *
+     * @example
+     * ```typescript
+     * const node = LocalBinaryTypeTree.getNodeFromTree(5);
+     * if (node) {
+     *   console.log("Found type node with variants:", node.variants.length);
+     * }
+     * ```
+     */
     static getNodeFromTree(id: number): LNode | null;
+    /**
+     * Retrieves all concept variants for a specific type ID.
+     *
+     * @param typeId - The type ID to search for
+     * @returns An array of LConcept objects of the specified type
+     *
+     * @remarks
+     * This method retrieves the primary concept and all its variants that share the same type ID.
+     * Useful for getting all concepts of a particular type in one operation.
+     *
+     * @example
+     * ```typescript
+     * const concepts = LocalBinaryTypeTree.getTypeVariantsFromTree(5);
+     * console.log(`Found ${concepts.length} concepts of type 5`);
+     * ```
+     */
     static getTypeVariantsFromTree(typeId: number): LConcept[] | undefined;
+    /**
+     * Waits for local type data to be loaded into the tree.
+     *
+     * @returns A promise that resolves with "done" when data is loaded, or rejects with "not" after 25 seconds
+     *
+     * @remarks
+     * This method polls the IdentifierFlags.isLocalTypeLoaded flag every second.
+     * Ensures type data is ready before performing operations.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await LocalBinaryTypeTree.waitForDataToLoad();
+     *   console.log("Type data loaded");
+     * } catch (error) {
+     *   console.log("Loading timed out");
+     * }
+     * ```
+     */
     static waitForDataToLoad(): Promise<unknown>;
+    /**
+     * Periodically checks if local type data has been loaded.
+     *
+     * @param resolve - The promise resolve function to call when data is loaded
+     *
+     * @remarks
+     * This method recursively checks the IdentifierFlags.isLocalTypeLoaded flag every 1000ms.
+     */
     static checkFlag(resolve: any): any;
+    /**
+     * Retrieves all concept variants for a specific type ID filtered by user ID.
+     *
+     * @param typeId - The type ID to search for
+     * @param userId - The user ID to filter by
+     * @returns An array of LConcept objects of the specified type belonging to the specified user
+     *
+     * @remarks
+     * This method retrieves all concepts of a given type that belong to a specific user.
+     * Useful for user-specific concept management and filtering.
+     *
+     * @example
+     * ```typescript
+     * const userConcepts = await LocalBinaryTypeTree.getTypeVariantsFromTreeWithUserId(5, 42);
+     * console.log(`Found ${userConcepts.length} concepts of type 5 for user 42`);
+     * ```
+     */
     static getTypeVariantsFromTreeWithUserId(typeId: number, userId: number): Promise<LConcept[]>;
 }

package/dist/types/DataStructures/Local/LocalConceptData.d.ts

@@ -1,14 +1,114 @@
+/**
+ * @fileoverview Local Concepts Data management for the Concept Connection System.
+ * This module provides static methods for managing local concept data, including
+ * adding, retrieving, and querying concepts from local binary trees and memory.
+ * @module DataStructures/Local/LocalConceptData
+ */
 import { LConcept } from "./../Local/LConcept";
+/**
+ * Manages local concept data storage and retrieval.
+ * Provides static methods for managing concepts in memory and across multiple
+ * binary tree structures for efficient querying.
+ *
+ * @class LocalConceptsData
+ * @export
+ */
 export declare class LocalConceptsData {
+    /**
+     * Name identifier for this data structure.
+     * @type {string}
+     */
     name: string;
+    /**
+     * Creates a new LocalConceptsData instance.
+     *
+     * @constructor
+     */
     constructor();
+    /**
+     * Static array storing all local concepts in memory.
+     * @type {LConcept[]}
+     * @static
+     */
     static localconceptsArray: LConcept[];
+    /**
+     * Adds a concept to the local storage system.
+     * Stores the concept in the database and adds it to all relevant binary trees.
+     *
+     * @static
+     * @method AddConcept
+     * @param {LConcept} concept - The concept to add
+     * @returns {void}
+     */
     static AddConcept(concept: LConcept): void;
+    /**
+     * Adds a concept to memory only (without database storage).
+     * Updates all relevant binary trees for fast lookups.
+     *
+     * @static
+     * @method AddConceptToMemory
+     * @param {LConcept} concept - The concept to add to memory
+     * @returns {void}
+     */
     static AddConceptToMemory(concept: LConcept): void;
+    /**
+     * Retrieves a concept by its ID from the local binary tree.
+     *
+     * @static
+     * @async
+     * @method GetConcept
+     * @param {number} id - The ID of the concept to retrieve
+     * @returns {Promise<LConcept>} The concept if found, otherwise a default concept
+     */
     static GetConcept(id: number): Promise<LConcept>;
+    /**
+     * Retrieves a concept by its character value.
+     *
+     * @static
+     * @async
+     * @method GetConceptByCharacter
+     * @param {string} characterValue - The character value to search for
+     * @returns {Promise<LConcept>} The concept if found, otherwise a default concept
+     */
     static GetConceptByCharacter(characterValue: string): Promise<LConcept>;
+    /**
+     * Retrieves a concept by both character value and type ID.
+     * Useful for finding specific concepts when multiple concepts share the same character value.
+     *
+     * @static
+     * @async
+     * @method GetConceptByCharacterAndTypeLocal
+     * @param {string} character_value - The character value to search for
+     * @param {number} typeId - The type ID to match
+     * @returns {Promise<LConcept>} The concept if found, otherwise a default concept
+     */
     static GetConceptByCharacterAndTypeLocal(character_value: string, typeId: number): Promise<LConcept>;
+    /**
+     * Retrieves all concepts of a specific type.
+     *
+     * @static
+     * @method GetConceptsByTypeId
+     * @param {number} typeId - The type ID to filter by
+     * @returns {LConcept[]} Array of concepts with the specified type
+     */
     static GetConceptsByTypeId(typeId: number): LConcept[];
+    /**
+     * Retrieves concepts filtered by both type ID and user ID.
+     * Useful for multi-user environments.
+     *
+     * @static
+     * @async
+     * @method GetConceptsByTypeIdAndUser
+     * @param {number} typeId - The type ID to filter by
+     * @param {number} userId - The user ID to filter by
+     * @returns {Promise<LConcept[]>} Array of concepts matching both criteria
+     */
     static GetConceptsByTypeIdAndUser(typeId: number, userId: number): Promise<LConcept[]>;
+    /**
+     * Gets the name of this data structure.
+     *
+     * @method getName
+     * @returns {string} The name identifier
+     */
     getName(): string;
 }

package/dist/types/DataStructures/Local/LocalConnectionData.d.ts

@@ -1,16 +1,125 @@
+/**
+ * @fileoverview Local Connection Data management for the Concept Connection System.
+ * This module provides static methods for managing local connection data, including
+ * adding, removing, and retrieving connections from memory and database storage.
+ * @module DataStructures/Local/LocalConnectionData
+ */
 import { LConnection } from "./LConnection";
+/**
+ * Manages local connection data storage and retrieval.
+ * Provides static methods for managing connections in memory and database,
+ * with support for querying connections by composition and waiting for data loads.
+ *
+ * @class LocalConnectionData
+ * @export
+ */
 export declare class LocalConnectionData {
+    /**
+     * Name identifier for this data structure.
+     * @type {string}
+     */
     name: string;
+    /**
+     * Creates a new LocalConnectionData instance.
+     *
+     * @constructor
+     */
     constructor();
+    /**
+     * Static array storing all local connections in memory.
+     * @type {LConnection[]}
+     * @static
+     */
     static connectionArray: LConnection[];
+    /**
+     * Static dictionary/map for fast connection lookups by ID.
+     * @type {LConnection[]}
+     * @static
+     */
     static connectionDictionary: LConnection[];
+    /**
+     * Checks if a connection already exists in the array.
+     *
+     * @static
+     * @method CheckContains
+     * @param {LConnection} connection - The connection to check
+     * @returns {boolean} True if the connection exists, false otherwise
+     */
     static CheckContains(connection: LConnection): boolean;
+    /**
+     * Adds a connection to the local storage system.
+     * If the connection already exists, it is removed and re-added.
+     * Stores non-temporary connections with valid IDs to the database.
+     *
+     * @static
+     * @method AddConnection
+     * @param {LConnection} connection - The connection to add
+     * @returns {void}
+     */
     static AddConnection(connection: LConnection): void;
+    /**
+     * Adds a connection to the fast lookup dictionary.
+     *
+     * @static
+     * @method AddToDictionary
+     * @param {LConnection} connection - The connection to add to dictionary
+     * @returns {void}
+     */
     static AddToDictionary(connection: LConnection): void;
+    /**
+     * Removes a connection from the local storage system.
+     * Removes from both the array and the database (if it has a valid ID).
+     *
+     * @static
+     * @method RemoveConnection
+     * @param {LConnection} connection - The connection to remove
+     * @returns {void}
+     */
     static RemoveConnection(connection: LConnection): void;
+    /**
+     * Retrieves a connection by its ID.
+     *
+     * @static
+     * @method GetConnection
+     * @param {number} id - The ID of the connection to retrieve
+     * @returns {LConnection | null} The connection if found, null otherwise
+     */
     static GetConnection(id: number): LConnection | null;
+    /**
+     * Waits for the local connection data to finish loading.
+     * Uses a polling mechanism to check the loading flag.
+     *
+     * @static
+     * @async
+     * @method waitForDataToLoad
+     * @returns {Promise<string>} Resolves with "done" when loaded, rejects after 25 seconds
+     */
     static waitForDataToLoad(): Promise<unknown>;
+    /**
+     * Polling function that checks if connection data has finished loading.
+     *
+     * @static
+     * @method checkFlag
+     * @param {Function} resolve - The promise resolve function
+     * @returns {*} Resolves immediately if loaded, otherwise schedules next check
+     */
     static checkFlag(resolve: any): any;
+    /**
+     * Retrieves all connections of a specific composition (by type ID).
+     * Waits for data to load if necessary.
+     *
+     * @static
+     * @async
+     * @method GetConnectionsOfCompositionLocal
+     * @param {number} id - The composition type ID to filter by
+     * @returns {Promise<LConnection[]>} Array of connections with the specified type
+     */
     static GetConnectionsOfCompositionLocal(id: number): Promise<LConnection[]>;
+    /**
+     * Gets the name of this data structure.
+     *
+     * @method getName
+     * @returns {string} The name identifier
+     */
     getName(): string;
 }