mftsccs-node 0.0.56 → 0.0.58

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

@@ -0,0 +1,209 @@
+/**
+ * @fileoverview ConnectionData module for managing connection storage and retrieval in CCS-JS.
+ * This module provides centralized management of connections using binary tree indexing
+ * for efficient ID-based and type-based lookups.
+ * @module DataStructures/ConnectionData
+ */
+import { Connection } from "./Connection";
+/**
+ * Central repository for managing all connections in the CCS system.
+ * Provides binary tree indexing for efficient connection retrieval by ID and type.
+ * Maintains both in-memory (tree structures) and persistent (IndexedDB) storage.
+ *
+ * @class ConnectionData
+ * @example
+ * ```typescript
+ * // Add a connection to the system
+ * ConnectionData.AddConnection(myConnection);
+ *
+ * // Retrieve a connection by ID
+ * const connection = await ConnectionData.GetConnection(123);
+ *
+ * // Get connections of a composition type
+ * const connections = await ConnectionData.GetConnectionsOfCompositionLocal(10);
+ * ```
+ *
+ * @remarks
+ * This class uses static methods and properties, functioning as a singleton data store.
+ * It coordinates ID-based and type-based indexing for optimized query performance.
+ */
+export declare class ConnectionData {
+    /** Name identifier for this data structure */
+    name: string;
+    /**
+     * Creates a new ConnectionData instance.
+     * @remarks This is rarely instantiated as the class primarily uses static methods.
+     */
+    constructor();
+    /** Legacy array storage for connections (deprecated in favor of tree structures) */
+    static connectionArray: Connection[];
+    /** Dictionary-style storage for quick connection lookups by ID */
+    static connectionDictionary: Connection[];
+    /**
+     * Checks if a connection already exists in the connections array.
+     *
+     * @param {Connection} connection - The connection to check for existence
+     * @returns {boolean} True if the connection exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const exists = ConnectionData.CheckContains(myConnection);
+     * if (!exists) {
+     *   // Add the connection
+     * }
+     * ```
+     */
+    static CheckContains(connection: Connection): boolean;
+    /**
+     * Adds a connection to persistent storage (IndexedDB) only.
+     * Does not update in-memory tree structures.
+     *
+     * @param {Connection} connection - The connection to store persistently
+     *
+     * @example
+     * ```typescript
+     * ConnectionData.AddConnectionToStorage(myConnection);
+     * ```
+     */
+    static AddConnectionToStorage(connection: Connection): void;
+    /**
+     * Adds a connection to both persistent storage and all in-memory tree indexes.
+     * This is the primary method for adding connections to the system.
+     *
+     * @param {Connection} connection - The connection to add
+     *
+     * @example
+     * ```typescript
+     * const newConnection = new Connection(...);
+     * ConnectionData.AddConnection(newConnection);
+     * ```
+     *
+     * @remarks
+     * Updates two tree structures:
+     * - ConnectionBinaryTree (ID-based lookup)
+     * - ConnectionTypeTree (type-based lookup)
+     * Skips temporary connections (isTemp = true)
+     */
+    static AddConnection(connection: Connection): void;
+    /**
+     * Adds a connection to in-memory tree structures only, without persisting to storage.
+     * Useful for temporary connections or when storage is handled separately.
+     *
+     * @param {Connection} connection - The connection to add to memory
+     *
+     * @example
+     * ```typescript
+     * ConnectionData.AddConnectionToMemory(temporaryConnection);
+     * ```
+     *
+     * @remarks
+     * Updates tree structures without touching IndexedDB.
+     * Skips temporary connections (isTemp = true)
+     */
+    static AddConnectionToMemory(connection: Connection): void;
+    /**
+     * Adds a connection to the dictionary for quick ID-based lookups.
+     *
+     * @param {Connection} connection - The connection to add to dictionary
+     *
+     * @example
+     * ```typescript
+     * ConnectionData.AddToDictionary(myConnection);
+     * ```
+     */
+    static AddToDictionary(connection: Connection): void;
+    /**
+     * Removes a connection from all storage locations (memory trees and persistent storage).
+     *
+     * @param {Connection} connection - The connection to remove
+     *
+     * @example
+     * ```typescript
+     * ConnectionData.RemoveConnection(obsoleteConnection);
+     * ```
+     *
+     * @remarks
+     * Removes from:
+     * - IndexedDB persistent storage
+     * - ConnectionBinaryTree (ID index)
+     * - ConnectionTypeTree (type index)
+     * Only processes connections with valid IDs (id != 0)
+     */
+    static RemoveConnection(connection: Connection): void;
+    /**
+     * Returns the root node of the connection binary tree.
+     * Used for direct tree traversal or debugging.
+     *
+     * @returns {Node | null} The root node of the connection tree
+     *
+     * @example
+     * ```typescript
+     * const tree = ConnectionData.GetConnectionTree();
+     * if (tree) {
+     *   console.log("Tree root:", tree.key);
+     * }
+     * ```
+     */
+    static GetConnectionTree(): import("./ConnectionBinaryTree/ConnectionNode").ConnectionNode | null;
+    /**
+     * Returns the root node of the connection type tree.
+     * Used for direct tree traversal or debugging.
+     *
+     * @returns {Node | null} The root node of the connection type tree
+     *
+     * @example
+     * ```typescript
+     * const tree = ConnectionData.GetConnectionTypeTree();
+     * ```
+     */
+    static GetConnectionTypeTree(): import("./ConnectionBinaryTree/ConnectionNode").ConnectionNode | null;
+    /**
+     * Retrieves a connection by its ID from the binary tree index.
+     *
+     * @param {number} id - The connection ID to retrieve
+     * @returns {Promise<Connection>} The connection if found, or a default connection if not found
+     *
+     * @example
+     * ```typescript
+     * const connection = await ConnectionData.GetConnection(123);
+     * if (connection.id !== 0) {
+     *   console.log("Found connection:", connection.ofTheConceptId, "->", connection.toTheConceptId);
+     * }
+     * ```
+     *
+     * @remarks
+     * Returns a default connection (id = 0) if the connection is not found.
+     * Uses ConnectionBinaryTree for O(log n) lookup performance.
+     */
+    static GetConnection(id: number): Promise<Connection>;
+    /**
+     * Retrieves all connections of a specific composition type ID from the type tree.
+     * Includes the main connection and all its variants.
+     *
+     * @param {number} id - The type ID to filter by
+     * @returns {Promise<Connection[]>} Array of connections with the specified type
+     *
+     * @example
+     * ```typescript
+     * const connections = await ConnectionData.GetConnectionsOfCompositionLocal(10);
+     * console.log(`Found ${connections.length} connections of type 10`);
+     * ```
+     *
+     * @remarks
+     * Uses ConnectionTypeTree to retrieve the main connection and all variant connections.
+     * Returns an empty array if no connections are found for the type.
+     */
+    static GetConnectionsOfCompositionLocal(id: number): Promise<Connection[]>;
+    /**
+     * Returns the name identifier of this data structure instance.
+     *
+     * @returns {string} The name "Connection Array"
+     *
+     * @example
+     * ```typescript
+     * const connectionData = new ConnectionData();
+     * console.log(connectionData.getName()); // "Connection Array"
+     * ```
+     */
+    getName(): string;
+}

package/dist/types/DataStructures/Count/CountInfo.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Defines the CountInfo class for storing connection count information.
+ * @module DataStructures/Count/CountInfo
+ */
+/**
+ * Represents information about connection counts for a concept.
+ * This class stores the count of connections of a specific type
+ * associated with a particular concept, useful for analytics and statistics.
+ *
+ * @class CountInfo
+ *
+ * @example
+ * ```typescript
+ * const countInfo = new CountInfo();
+ * countInfo.conceptId = 123;
+ * countInfo.connectionTypeId = 456;
+ * countInfo.connectionType = "likes";
+ * countInfo.count = 42;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Tracking follower counts
+ * const followerCount = new CountInfo();
+ * followerCount.conceptId = 100; // User ID
+ * followerCount.connectionType = "followers";
+ * followerCount.count = 1523;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple connection counts for a post
+ * const likesCount = new CountInfo();
+ * likesCount.conceptId = 200; // Post ID
+ * likesCount.connectionType = "likes";
+ * likesCount.count = 350;
+ *
+ * const commentsCount = new CountInfo();
+ * commentsCount.conceptId = 200; // Same Post ID
+ * commentsCount.connectionType = "comments";
+ * commentsCount.count = 45;
+ * ```
+ */
+export declare class CountInfo {
+    /**
+     * The ID of the concept for which connections are being counted.
+     * Identifies the entity whose connections are being tracked.
+     *
+     * @type {number}
+     * @default 0
+     */
+    conceptId: number;
+    /**
+     * The ID of the connection type being counted.
+     * Identifies which type of connection this count represents.
+     *
+     * @type {number}
+     * @default 0
+     */
+    connectionTypeId: number;
+    /**
+     * The string name/description of the connection type.
+     * Human-readable identifier for the type of connection being counted.
+     *
+     * @type {string}
+     * @default ""
+     *
+     * @example "likes", "follows", "comments", "shares"
+     */
+    connectionType: string;
+    /**
+     * The number of connections of this type.
+     * The actual count value representing how many connections exist.
+     *
+     * @type {number}
+     * @default 0
+     */
+    count: number;
+}

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

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

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

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

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