mftsccs-node 0.0.57 → 0.0.58

package/dist/types/DataStructures/FilterSearch.d.ts

@@ -1,9 +1,93 @@
+/**
+ * @fileoverview Defines the FilterSearch class for creating filter criteria in search queries.
+ * @module DataStructures/FilterSearch
+ */
+/**
+ * Represents a single filter criterion for search operations.
+ * This class encapsulates the conditions for filtering search results based on
+ * specific fields, values, and logical operators.
+ *
+ * @class FilterSearch
+ *
+ * @example
+ * ```typescript
+ * const filter = new FilterSearch();
+ * filter.type = "age";
+ * filter.search = "25";
+ * filter.logicoperator = ">=";
+ * filter.index = 0;
+ * filter.composition = true;
+ * filter.name = "age_filter";
+ * filter.operateon = "value";
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // String equality filter
+ * const nameFilter = new FilterSearch();
+ * nameFilter.type = "name";
+ * nameFilter.search = "John";
+ * nameFilter.logicoperator = "=";
+ * nameFilter.operateon = "text";
+ * ```
+ */
 export declare class FilterSearch {
+    /**
+     * The type or field name to filter on.
+     * Specifies which property of the entity should be evaluated by this filter.
+     *
+     * @type {string}
+     * @default ""
+     */
     type: string;
+    /**
+     * The search value or term to filter against.
+     * The value that will be compared with the specified field using the logic operator.
+     *
+     * @type {string}
+     * @default ""
+     */
     search: string;
+    /**
+     * The logical operator for comparison.
+     * Determines how the search value is compared with the field value.
+     * Common operators include: "=", "!=", ">", "<", ">=", "<=", "LIKE", "IN".
+     *
+     * @type {string}
+     * @default "="
+     */
     logicoperator: string;
+    /**
+     * The index or position of this filter in a filter array.
+     * Used for ordering and referencing filters in complex filter combinations.
+     *
+     * @type {number}
+     * @default 0
+     */
     index: number;
+    /**
+     * Flag indicating whether this filter applies to compositions.
+     * When true, the filter is evaluated within a composition context.
+     *
+     * @type {boolean}
+     * @default true
+     */
     composition: boolean;
+    /**
+     * A descriptive name for this filter.
+     * Useful for identifying and debugging filter operations.
+     *
+     * @type {string}
+     * @default ""
+     */
     name: string;
+    /**
+     * The operand type or target field for the filter operation.
+     * Specifies what kind of data or field the filter operates on
+     * (e.g., "value", "text", "date", "id").
+     *
+     * @type {string}
+     * @default ""
+     */
     operateon: string;
 }

package/dist/types/DataStructures/IdentifierFlags.d.ts

@@ -1,11 +1,45 @@
+/**
+ * @fileoverview IdentifierFlags module for tracking data loading states in CCS-JS.
+ * This module provides centralized flags for synchronizing data loading across different storage structures.
+ * @module DataStructures/IdentifierFlags
+ */
+/**
+ * Centralized flags for tracking the loading state of various data structures.
+ * Used for synchronization when loading initial data from backend or local storage.
+ *
+ * @class IdentifierFlags
+ * @example
+ * ```typescript
+ * // Check if data is loaded
+ * if (IdentifierFlags.isDataLoaded) {
+ *   console.log("Concept data ready");
+ * }
+ *
+ * // Set flag when loading completes
+ * IdentifierFlags.isDataLoaded = true;
+ * ```
+ *
+ * @remarks
+ * All properties are static flags (booleans) used across the application
+ * to coordinate asynchronous data loading operations.
+ */
 export declare class IdentifierFlags {
+    /** Flag indicating if the type tree has been loaded from backend */
     static isTypeLoaded: boolean;
+    /** Flag indicating if the character tree has been loaded from backend */
     static isCharacterLoaded: boolean;
+    /** Flag indicating if the main concept data has been loaded from backend */
     static isDataLoaded: boolean;
+    /** Flag indicating if local concept data has been loaded from IndexedDB */
     static isLocalDataLoaded: boolean;
+    /** Flag indicating if local character tree has been loaded from IndexedDB */
     static isLocalCharacterLoaded: boolean;
+    /** Flag indicating if local type tree has been loaded from IndexedDB */
     static isLocalTypeLoaded: boolean;
+    /** Flag indicating if connection data has been loaded from backend */
     static isConnectionLoaded: boolean;
+    /** Flag indicating if connection type tree has been loaded from backend */
     static isConnectionTypeLoaded: boolean;
+    /** Flag indicating if local connection data has been loaded from IndexedDB */
     static isLocalConnectionLoaded: boolean;
 }

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

@@ -1,21 +1,126 @@
+/**
+ * @fileoverview Local Concept data structure for the Concept Connection System.
+ * This module defines the LConcept class which represents a local concept entity
+ * with various identifiers, timestamps, and metadata properties.
+ * @module DataStructures/Local/LConcept
+ */
 import { Concept } from "../Concept";
+/**
+ * Represents a Local Concept in the Concept Connection System.
+ * A local concept is a data structure that stores concept information locally
+ * before or instead of synchronizing with a remote server.
+ *
+ * @class LConcept
+ * @export
+ */
 export declare class LConcept {
+    /**
+     * Unique identifier for the concept.
+     * @type {number}
+     */
     id: number;
+    /**
+     * Ghost identifier for tracking purposes.
+     * @type {number}
+     */
     ghostId: number;
+    /**
+     * Identifier of the user who owns this concept.
+     * @type {number}
+     */
     userId: number;
+    /**
+     * Type identifier that classifies this concept.
+     * @type {number}
+     */
     typeId: number;
+    /**
+     * Category identifier for grouping concepts.
+     * @type {number}
+     */
     categoryId: number;
+    /**
+     * Access control identifier determining permissions.
+     * @type {number}
+     */
     accessId: number;
+    /**
+     * The character or text value representing this concept.
+     * @type {string}
+     */
     characterValue: string;
+    /**
+     * Character representation of the type.
+     * @type {string}
+     */
     typeCharacter: string;
+    /**
+     * Timestamp when this concept was created or entered.
+     * @type {Date | string}
+     */
     entryTimeStamp: Date | string;
+    /**
+     * Identifier for the referent data.
+     * @type {number}
+     */
     referentId: number;
+    /**
+     * Timestamp when this concept was last updated.
+     * @type {Date | string}
+     */
     updatedTimeStamp: Date | string;
+    /**
+     * Reference to the type concept (can be LConcept or Concept).
+     * @type {LConcept | null | void | Concept}
+     */
     type: LConcept | null | void | Concept;
+    /**
+     * Indicates whether this concept is newly created.
+     * @type {boolean}
+     */
     isNew: boolean;
+    /**
+     * Indicates whether this concept is a composition.
+     * @type {boolean}
+     * @default false
+     */
     isComposition: boolean;
+    /**
+     * Indicates whether this concept is temporary.
+     * @type {boolean}
+     * @default false
+     */
     isTemp: boolean;
+    /**
+     * Application identifier for multi-application support.
+     * @type {number}
+     * @default 999
+     */
     applicationId: number;
+    /**
+     * Creates a new LConcept instance.
+     *
+     * @constructor
+     * @param {number} id - Unique identifier for the concept
+     * @param {number} userId - Identifier of the user who owns this concept
+     * @param {number} typeId - Type identifier that classifies this concept
+     * @param {number} categoryId - Category identifier for grouping concepts
+     * @param {number} accessId - Access control identifier
+     * @param {string} characterValue - The character or text value of this concept
+     * @param {string} typeCharacter - Character representation of the type
+     * @param {boolean} [isNew=false] - Whether this concept is newly created
+     * @param {Date | string} entryTimeStamp - Creation timestamp
+     * @param {Date | string} updatedTimeStamp - Last update timestamp
+     * @param {number} referentId - Identifier for the referent data
+     * @param {number} [applicationId=999] - Application identifier
+     */
     constructor(id: number, userId: number, typeId: number, categoryId: number, accessId: number, characterValue: string, typeCharacter: string, isNew: boolean | undefined, entryTimeStamp: Date | string, updatedTimeStamp: Date | string, referentId: number, applicationId?: number);
+    /**
+     * Logs the type identifier of this concept to the console.
+     * Used primarily for debugging purposes.
+     *
+     * @method getType
+     * @returns {void}
+     */
     getType(): void;
 }

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

@@ -1,18 +1,101 @@
+/**
+ * @fileoverview Local Connection data structure for the Concept Connection System.
+ * This module defines the LConnection class which represents a connection between
+ * concepts in the local storage system.
+ * @module DataStructures/Local/LConnection
+ */
 import { LConcept } from "./LConcept";
+/**
+ * Represents a Local Connection between concepts in the Concept Connection System.
+ * A local connection links two concepts and stores metadata about that relationship.
+ *
+ * @class LConnection
+ * @export
+ */
 export declare class LConnection {
+    /**
+     * Unique identifier for the connection.
+     * @type {number}
+     */
     id: number;
+    /**
+     * Ghost identifier for tracking purposes.
+     * @type {number}
+     */
     ghostId: number;
+    /**
+     * Identifier of the source concept (from concept).
+     * @type {number}
+     */
     ofTheConceptId: number;
+    /**
+     * Identifier of the target concept (to concept).
+     * @type {number}
+     */
     toTheConceptId: number;
+    /**
+     * Timestamp when this connection was created or entered.
+     * @type {Date | string}
+     */
     entryTimeStamp: Date | string;
+    /**
+     * Date and time when this connection is terminated or expires.
+     * @type {Date}
+     */
     terminationDateTime: Date;
+    /**
+     * Access control identifier determining permissions.
+     * @type {number}
+     */
     accessId: number;
+    /**
+     * Type identifier that classifies this connection.
+     * @type {number}
+     */
     typeId: number;
+    /**
+     * Order identifier for sequencing connections.
+     * @type {number}
+     */
     orderId: number;
+    /**
+     * Character representation of the connection type.
+     * @type {string}
+     */
     typeCharacter: string;
+    /**
+     * Timestamp of the last local synchronization.
+     * @type {Date}
+     */
     localSyncTime: Date;
+    /**
+     * Indicates whether this connection is temporary.
+     * @type {boolean}
+     * @default false
+     */
     isTemp: boolean;
+    /**
+     * Application identifier for multi-application support.
+     * @type {number}
+     * @default 999
+     */
     applicationId: number;
+    /**
+     * Reference to the type concept for this connection.
+     * @type {LConcept}
+     */
     type: LConcept;
+    /**
+     * Creates a new LConnection instance.
+     *
+     * @constructor
+     * @param {number} [id=0] - Unique identifier for the connection
+     * @param {number} ofTheConceptId - Identifier of the source concept
+     * @param {number} toTheConceptId - Identifier of the target concept
+     * @param {number} typeId - Type identifier that classifies this connection
+     * @param {number} orderId - Order identifier for sequencing
+     * @param {number} accessId - Access control identifier
+     * @param {number} [applicationId=999] - Application identifier
+     */
     constructor(id: number | undefined, ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId: number, accessId: number, applicationId?: number);
 }

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

@@ -1,27 +1,217 @@
+/**
+ * @fileoverview Local Node data structure for binary tree operations.
+ * This module defines the LNode class which represents a node in an AVL
+ * (self-balancing) binary tree for storing and managing LConcept instances.
+ * @module DataStructures/Local/LNode
+ */
 import { LConcept } from "./LConcept";
+/**
+ * Represents a node in an AVL binary tree for local concepts.
+ * This class implements self-balancing tree operations including rotations,
+ * insertions, deletions, and lookups for efficient concept management.
+ *
+ * @class LNode
+ * @export
+ */
 export declare class LNode {
+    /**
+     * The key used for tree ordering (can be number or string).
+     * @type {any}
+     */
     key: any;
+    /**
+     * The concept value stored in this node.
+     * @type {LConcept}
+     */
     value: LConcept;
+    /**
+     * Reference to the left child node.
+     * @type {LNode | null}
+     */
     leftNode: LNode | null;
+    /**
+     * Reference to the right child node.
+     * @type {LNode | null}
+     */
     rightNode: LNode | null;
+    /**
+     * Reference to current node for linking nodes with same key.
+     * @type {LNode | null}
+     */
     currentNode: LNode | null;
+    /**
+     * Array of variant nodes with same key but different properties.
+     * @type {LNode[]}
+     * @default []
+     */
     variants: LNode[];
+    /**
+     * Height of the node in the tree for AVL balancing.
+     * @type {number}
+     * @default 1
+     */
     height: number;
+    /**
+     * Creates a new LNode instance.
+     *
+     * @constructor
+     * @param {any} key - The key used for tree ordering
+     * @param {LConcept} value - The concept value to store
+     * @param {LNode | null} leftNode - Reference to left child
+     * @param {LNode | null} rightNode - Reference to right child
+     */
     constructor(key: any, value: LConcept, leftNode: LNode | null, rightNode: LNode | null);
+    /**
+     * Adds a current node to the chain based on typeId.
+     * This method links nodes with different typeIds.
+     *
+     * @method addCurrentNode
+     * @param {LNode} passedNode - The node to add
+     * @param {LNode | null} node - The current node in the chain
+     * @returns {LNode | null} The updated node chain
+     */
     addCurrentNode(passedNode: LNode, node: LNode | null): LNode;
+    /**
+     * Adds a node as a variant if it has the same key but different id.
+     * This method manages variants (nodes with same key but different properties).
+     *
+     * @method addCurrentNodeType
+     * @param {LNode} passedNode - The node to add as variant
+     * @param {LNode | null} node - The current node
+     * @returns {LNode | null} The updated node
+     */
     addCurrentNodeType(passedNode: LNode, node: LNode | null): LNode;
+    /**
+     * Adds a node to the AVL tree with automatic balancing.
+     * This method performs standard AVL insertion with rotations.
+     *
+     * @method addNode
+     * @param {LNode} passedNode - The node to insert
+     * @param {LNode | null} node - The current node in traversal
+     * @param {number} height - Current height for balancing
+     * @returns {LNode | null} The root of the updated subtree
+     */
     addNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    /**
+     * Adds a character node to the tree with variant management.
+     * Handles nodes with character keys and manages variants for duplicate keys.
+     *
+     * @method addCharacterNode
+     * @param {LNode} passedNode - The node to insert
+     * @param {LNode | null} node - The current node in traversal
+     * @param {number} height - Current height for balancing
+     * @returns {LNode | null} The root of the updated subtree
+     */
     addCharacterNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    /**
+     * Adds a type node to the tree with variant management.
+     * Handles nodes with typeId keys and manages variants for duplicate typeIds.
+     *
+     * @method addTypeNode
+     * @param {LNode} passedNode - The node to insert
+     * @param {LNode | null} node - The current node in traversal
+     * @param {number} height - Current height for balancing
+     * @returns {LNode | null} The root of the updated subtree
+     */
     addTypeNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    /**
+     * Performs a right rotation for AVL tree balancing.
+     *
+     * @method rightRotate
+     * @param {LNode | null} y - The node to rotate
+     * @returns {LNode | null} The new root of the rotated subtree
+     */
     rightRotate(y: LNode | null): LNode | null;
+    /**
+     * Performs a left rotation for AVL tree balancing.
+     *
+     * @method leftRotate
+     * @param {LNode | null} x - The node to rotate
+     * @returns {LNode | null} The new root of the rotated subtree
+     */
     leftRotate(x: LNode | null): LNode | null;
+    /**
+     * Gets the height of a node.
+     *
+     * @method getHeight
+     * @param {LNode | null} node - The node to get height from
+     * @returns {number} The height of the node, or 0 if null
+     */
     getHeight(node: LNode | null): number;
+    /**
+     * Calculates the balance factor of a node.
+     * Balance factor = height(left subtree) - height(right subtree)
+     *
+     * @method getBalanceFactor
+     * @param {LNode | null} N - The node to calculate balance factor for
+     * @returns {number} The balance factor (-2, -1, 0, 1, or 2)
+     */
     getBalanceFactor(N: LNode | null): number;
+    /**
+     * Searches for a node by numeric id.
+     *
+     * @method getFromNode
+     * @param {number} id - The id to search for
+     * @param {LNode | null} node - The current node in traversal
+     * @returns {LNode | null} The found node or null
+     */
     getFromNode(id: number, node: LNode | null): LNode | null;
+    /**
+     * Searches for a node by character value.
+     *
+     * @method getCharacterFromNode
+     * @param {string} value - The character value to search for
+     * @param {LNode | null} node - The current node in traversal
+     * @returns {LNode | null} The found node or null
+     */
     getCharacterFromNode(value: string, node: LNode | null): LNode | null;
+    /**
+     * Searches for a node by both character value and type id.
+     * This method also searches through variants to find exact matches.
+     *
+     * @method getFromNodeWithCharacterAndType
+     * @param {string} value - The character value to search for
+     * @param {number} typeId - The type identifier to match
+     * @param {LNode | null} node - The current node in traversal
+     * @returns {LNode | null} The found node or null
+     */
     getFromNodeWithCharacterAndType(value: string, typeId: number, node: LNode | null): LNode | null;
+    /**
+     * Removes a node from the tree by id.
+     * Uses standard BST deletion with in-order successor replacement.
+     *
+     * @method removeNode
+     * @param {LNode | null} passedNode - The current node in traversal
+     * @param {number} id - The id of the node to remove
+     * @returns {LNode | null} The root of the updated subtree
+     */
     removeNode(passedNode: LNode | null, id: number): LNode | null;
+    /**
+     * Removes a node with variant management.
+     * If the node has variants, replaces the removed node with first variant.
+     *
+     * @method removeNodeWithVariants
+     * @param {LNode | null} passedNode - The current node in traversal
+     * @param {any} typeIdentifier - The type identifier (key) to search for
+     * @param {number} conceptId - The concept id to remove
+     * @returns {LNode | null} The root of the updated subtree
+     */
     removeNodeWithVariants(passedNode: LNode | null, typeIdentifier: any, conceptId: number): LNode | null;
+    /**
+     * Counts the total number of nodes in the subtree.
+     *
+     * @method countNodeBelow
+     * @param {LNode | null} root - The root of the subtree
+     * @returns {number} The total count of nodes
+     */
     countNodeBelow(root: LNode | null): number;
+    /**
+     * Finds the in-order successor (leftmost node in right subtree).
+     * Used during node deletion.
+     *
+     * @method inOrderSuccessor
+     * @param {LNode} root - The root to find successor from
+     * @returns {LNode} The in-order successor node
+     */
     inOrderSuccessor(root: LNode): LNode;
 }