mftsccs-node 0.0.56 → 0.0.58

package/dist/types/Database/NoIndexDb.d.ts

@@ -0,0 +1,178 @@
+/**
+ * No-operation IndexedDB interface module for environments without IndexedDB support.
+ *
+ * This module provides stub implementations of database operations that are used when
+ * IndexedDB is not available or when database functionality needs to be disabled.
+ * All functions are no-ops or return default values, allowing the application to
+ * run without actual database persistence.
+ *
+ * @module Database/NoIndexDb
+ * @see https://documentation.freeschema.com for reference
+ */
+import { SettingData } from "../DataStructures/SettingData";
+/**
+ * Opens or returns a reference to the IndexedDB database.
+ *
+ * In this no-op implementation, it simply returns the static database reference
+ * from IndexDb without performing any actual initialization.
+ *
+ * @param databaseName - The name of the database to open
+ * @returns The static IDBDatabase reference from IndexDb.db
+ *
+ * @example
+ * ```typescript
+ * const db = openDatabase('concepts-db');
+ * // Returns IndexDb.db without initialization
+ * ```
+ *
+ * @remarks
+ * This is a stub implementation used when full database functionality is not needed.
+ *
+ * @see IndexDb for the database singleton
+ */
+export declare function openDatabase(databaseName: string): IDBDatabase;
+/**
+ * Stores an object to the database (no-op implementation).
+ *
+ * This function provides a stub for storing data to IndexedDB. In this no-op
+ * implementation, it does not perform any actual storage operations.
+ *
+ * @param databaseName - The name of the database or object store
+ * @param object - The object to store (can be any type)
+ *
+ * @example
+ * ```typescript
+ * const concept = { id: 1, name: 'Example' };
+ * storeToDatabase('concepts', concept);
+ * // No actual storage occurs
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Use the full database module for actual persistence.
+ */
+export declare function storeToDatabase(databaseName: string, object: any): void;
+/**
+ * Retrieves statistics and settings from the database.
+ *
+ * Returns a new SettingData instance initialized with default values.
+ * This provides a consistent interface for accessing settings even when
+ * database functionality is disabled.
+ *
+ * @returns A new SettingData instance with AI features enabled (true)
+ *
+ * @example
+ * ```typescript
+ * const stats = GetStatsFromDatabase();
+ * // Returns SettingData with default configuration
+ * ```
+ *
+ * @remarks
+ * The returned SettingData is initialized with AI features enabled by default.
+ *
+ * @see SettingData for the settings data structure
+ */
+export declare function GetStatsFromDatabase(): SettingData;
+/**
+ * Updates the AI flag in settings (no-op implementation).
+ *
+ * This function provides a stub for updating AI-related settings in the database.
+ * In this no-op implementation, it does not perform any actual updates.
+ *
+ * @param object - The SettingData object containing the new AI flag value
+ *
+ * @example
+ * ```typescript
+ * const settings = new SettingData(false);
+ * AiUpdateFlag(settings);
+ * // No actual update occurs
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Changes are not persisted.
+ *
+ * @see SettingData for the settings data structure
+ */
+export declare function AiUpdateFlag(object: SettingData): void;
+/**
+ * Retrieves an object from the database by type and ID (no-op implementation).
+ *
+ * This async function provides a stub for fetching data from IndexedDB based on
+ * type and ID. In this no-op implementation, it returns undefined.
+ *
+ * @param databaseName - The name of the database or object store
+ * @param type - The type of object to retrieve (e.g., 'concept', 'setting')
+ * @param id - The numeric ID of the object to retrieve
+ * @returns Promise resolving to undefined
+ *
+ * @example
+ * ```typescript
+ * const concept = await getFromDatabaseWithType('concepts', 'concept', 123);
+ * // Returns undefined
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Use the full database module for actual retrieval.
+ */
+export declare function getFromDatabaseWithType(databaseName: string, type: string, id: number): Promise<void>;
+/**
+ * Retrieves objects from the database using legacy method (no-op implementation).
+ *
+ * This async function provides a stub for the older method of fetching data from
+ * IndexedDB. In this no-op implementation, it returns undefined.
+ *
+ * @param databaseName - The name of the database or object store
+ * @returns Promise resolving to undefined
+ *
+ * @example
+ * ```typescript
+ * const data = await getFromDatabaseWithTypeOld('concepts');
+ * // Returns undefined
+ * ```
+ *
+ * @remarks
+ * This is a legacy method maintained for backward compatibility. Use getFromDatabaseWithType
+ * for new implementations.
+ *
+ * @see getFromDatabaseWithType for the current retrieval method
+ */
+export declare function getFromDatabaseWithTypeOld(databaseName: string): Promise<void>;
+/**
+ * Removes an object from the database by ID (no-op implementation).
+ *
+ * This function provides a stub for deleting data from IndexedDB. In this no-op
+ * implementation, it does not perform any actual deletion.
+ *
+ * @param databaseName - The name of the database or object store
+ * @param id - The numeric ID of the object to remove
+ *
+ * @example
+ * ```typescript
+ * removeFromDatabase('concepts', 123);
+ * // No actual deletion occurs
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Use the full database module for actual deletion.
+ */
+export declare function removeFromDatabase(databaseName: string, id: number): void;
+/**
+ * Retrieves all objects from the local database (no-op implementation).
+ *
+ * This async function provides a stub for fetching all data from a local IndexedDB
+ * object store. In this no-op implementation, it returns undefined.
+ *
+ * @param databaseName - The name of the database or object store
+ * @returns Promise resolving to undefined
+ *
+ * @example
+ * ```typescript
+ * const allConcepts = await getAllFromLocalDb('concepts');
+ * // Returns undefined
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Use the full database module for actual bulk retrieval.
+ *
+ * @see LocalIndexDb for local database operations
+ */
+export declare function getAllFromLocalDb(databaseName: string): Promise<void>;

package/dist/types/Database/indexdblocal.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Local IndexedDB management module for storing concepts locally in the browser.
+ *
+ * This module provides a singleton class that maintains a static reference to a local
+ * IndexedDB database connection. It serves as the primary interface for local browser
+ * storage of concept data in the Concept Connection System.
+ *
+ * @module Database/indexdblocal
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Singleton class managing the local IndexedDB database connection.
+ *
+ * LocalIndexDb provides a static database reference for local browser storage
+ * of concepts. This allows the application to maintain offline functionality
+ * and cache concept data locally.
+ *
+ * @remarks
+ * The static db property is shared across the application and should be initialized
+ * before any database operations are performed.
+ *
+ * @example
+ * ```typescript
+ * // Access the local database instance
+ * const database = LocalIndexDb.db;
+ * if (database) {
+ *   // Perform database operations
+ * }
+ * ```
+ *
+ * @see IndexDb for remote database operations
+ * @see https://documentation.freeschema.com for concept storage patterns
+ */
+export declare class LocalIndexDb {
+    /**
+     * Static reference to the local IndexedDB database instance.
+     *
+     * This property holds the active IDBDatabase connection for local storage.
+     * It should be initialized during application startup before any database
+     * operations are attempted.
+     *
+     * @type {IDBDatabase}
+     */
+    static db: IDBDatabase;
+}

package/dist/types/Database/indexeddb.d.ts

@@ -0,0 +1,46 @@
+/**
+ * IndexedDB management module for the Concept Connection System.
+ *
+ * This module provides a singleton class that maintains a static reference to an
+ * IndexedDB database connection. It serves as the primary interface for browser-based
+ * storage of concepts, settings, and other CCS data structures.
+ *
+ * @module Database/indexeddb
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Singleton class managing the IndexedDB database connection.
+ *
+ * IndexDb provides a static database reference that can be accessed throughout
+ * the application for storing and retrieving concept data, settings, and other
+ * persistent information in the browser's IndexedDB storage.
+ *
+ * @remarks
+ * The static db property is shared across the entire application. It should be
+ * initialized during application startup before performing any database operations.
+ * The current database schema version is 4.
+ *
+ * @example
+ * ```typescript
+ * // Access the database instance
+ * const database = IndexDb.db;
+ * if (database) {
+ *   // Perform database operations
+ *   const transaction = database.transaction(['concepts'], 'readonly');
+ * }
+ * ```
+ *
+ * @see LocalIndexDb for local-only database operations
+ * @see https://documentation.freeschema.com for database schema details
+ */
+export declare class IndexDb {
+    /**
+     * Static reference to the IndexedDB database instance.
+     *
+     * This property holds the active IDBDatabase connection used throughout
+     * the application. Must be initialized before use.
+     *
+     * @type {IDBDatabase}
+     */
+    static db: IDBDatabase;
+}

package/dist/types/Drawing/ConceptDraw.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Concept Draw Module for Concept Connection System (CCS-JS)
+ *
+ * This module handles the visual rendering of concepts on an HTML5 canvas.
+ * It provides a drawing loop that continuously renders concepts as triangles
+ * with automatic positioning and animation capabilities.
+ *
+ * @module Drawing/ConceptDraw
+ * @see https://documentation.freeschema.com for visualization reference
+ */
+/**
+ * Initializes and starts the main drawing loop for rendering concepts.
+ *
+ * @example
+ * ```typescript
+ * // Start the drawing loop
+ * DrawingLoop();
+ * ```
+ *
+ * @remarks
+ * Sets up a continuous drawing loop using setInterval that:
+ * - Targets 60 FPS (though currently draws at 2 FPS with 500ms interval)
+ * - Queries the canvas element with ID 'myCanvas'
+ * - Continuously calls MainDraw() to render concepts
+ *
+ * Note: The FPS and FRAME_RATE variables are declared but not currently used.
+ * The actual draw rate is 500ms (2 times per second), not 60 FPS.
+ */
+export declare function DrawingLoop(): void;

package/dist/types/Drawing/ConceptEvents.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Concept Events Module for Concept Connection System (CCS-JS)
+ *
+ * This module handles user interaction events with visual concepts on the canvas.
+ * It provides hit detection and selection functionality for concepts rendered as triangles.
+ *
+ * @module Drawing/ConceptEvents
+ * @see https://documentation.freeschema.com for interaction reference
+ */
+/**
+ * Detects and returns a concept at the given mouse coordinates.
+ *
+ * @param mouse_x_coordinate - The x-coordinate of the mouse position
+ * @param mouse_y_coordinate - The y-coordinate of the mouse position
+ * @returns The concept at the mouse position, or null if no concept was clicked
+ *
+ * @example
+ * ```typescript
+ * canvas.addEventListener('click', (event) => {
+ *   const rect = canvas.getBoundingClientRect();
+ *   const x = event.clientX - rect.left;
+ *   const y = event.clientY - rect.top;
+ *   const selected = selectConceptObject(x, y);
+ *   if (selected) {
+ *     console.log('Clicked concept:', selected.id);
+ *   }
+ * });
+ * ```
+ *
+ * @remarks
+ * Hit detection uses a rectangular bounding box approach:
+ * - Width: 100 pixels (50 pixels on each side from center)
+ * - Height: 100 pixels (from y coordinate downward)
+ *
+ * Boundary calculations:
+ * - Left: concept.x - 50
+ * - Right: concept.x + 50
+ * - Top: concept.y
+ * - Bottom: concept.y + 100
+ *
+ * Note: Although concepts are drawn as triangles, the hit detection uses
+ * a rectangular area for simplicity. This means clicks near the corners
+ * of the rectangle but outside the actual triangle will still register.
+ *
+ * @see {@link ConceptsData} for the data store being searched
+ */
+export declare function selectConceptObject(mouse_x_coordinate: number, mouse_y_coordinate: number): import("../app").Concept | null;

package/dist/types/Helpers/CheckIfExists.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Check If Exists Helper Module for Concept Connection System (CCS-JS)
+ *
+ * This module provides utility functions to verify the existence of concepts and connections
+ * within arrays. These functions are essential for avoiding duplicates and finding related
+ * entities in the CCS data structures.
+ *
+ * @module Helpers/CheckIfExists
+ * @see https://documentation.freeschema.com for data structure reference
+ */
+import { Concept } from "../DataStructures/Concept";
+import { Connection } from "../DataStructures/Connection";
+import { LConcept, LConnection } from "../app";
+/**
+ * Checks if a concept exists in an array of concepts by matching IDs.
+ *
+ * @param conceptList - Array of concepts to search through
+ * @param concept - The concept to search for
+ * @returns The found concept if it exists, otherwise returns a default concept
+ *
+ * @example
+ * ```typescript
+ * const concepts = [concept1, concept2, concept3];
+ * const found = CheckIfConceptsExistsInArray(concepts, concept2);
+ * if (found.id !== 0) {
+ *   console.log('Concept exists!');
+ * }
+ * ```
+ *
+ * @remarks
+ * Returns a default concept (created via CreateDefaultConcept) if the concept is not found.
+ * Always check the returned concept's ID to verify if a match was found.
+ */
+export declare function CheckIfConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept;
+/**
+ * Checks if concepts of the same type exist in an array, matching by type ID or character value.
+ *
+ * @param conceptList - Array of concepts to search through
+ * @param concept - The concept whose type to match against
+ * @returns Array of all concepts that match the same type
+ *
+ * @example
+ * ```typescript
+ * const concepts = [concept1, concept2, concept3];
+ * const sameType = CheckIfTypeConceptsExistsInArray(concepts, concept1);
+ * console.log(`Found ${sameType.length} concepts of the same type`);
+ * ```
+ *
+ * @remarks
+ * This function normalizes type character values by ensuring they start with "the_" prefix
+ * before comparison. It matches concepts by either:
+ * - Exact typeId match
+ * - Character value match (with "the_" prefix normalization)
+ */
+export declare function CheckIfTypeConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept[];
+/**
+ * Checks if LConcepts (lightweight concepts) of the same type exist in an array.
+ *
+ * @param conceptList - Array of LConcepts to search through
+ * @param concept - The LConcept whose type to match against
+ * @returns Array of all LConcepts that match the same type
+ *
+ * @example
+ * ```typescript
+ * const lconcepts = [lconcept1, lconcept2, lconcept3];
+ * const sameType = CheckIfTypeLConceptsExistsInArray(lconcepts, lconcept1);
+ * console.log(`Found ${sameType.length} LConcepts of the same type`);
+ * ```
+ *
+ * @remarks
+ * This is the LConcept variant of CheckIfTypeConceptsExistsInArray.
+ * LConcept is a lightweight representation that uses typeCharacter instead of type object.
+ * The function normalizes type character values by ensuring they start with "the_" prefix.
+ *
+ * @see {@link CheckIfTypeConceptsExistsInArray}
+ */
+export declare function CheckIfTypeLConceptsExistsInArray(conceptList: LConcept[] | undefined, concept: LConcept): LConcept[];
+/**
+ * Checks if a connection exists in an array of connections by matching IDs.
+ *
+ * @param connectionList - Array of connections to search through
+ * @param connection - The connection to search for
+ * @returns The found connection if it exists, otherwise returns a default connection with all zeros
+ *
+ * @example
+ * ```typescript
+ * const connections = [conn1, conn2, conn3];
+ * const found = CheckIfConnectionExistsInArray(connections, conn2);
+ * if (found.id !== 0) {
+ *   console.log('Connection exists!');
+ * }
+ * ```
+ *
+ * @remarks
+ * Returns a new Connection instance with all parameters set to 0 if the connection is not found.
+ * Always check the returned connection's ID to verify if a match was found.
+ */
+export declare function CheckIfConnectionExistsInArray(connectionList: Connection[] | undefined, connection: Connection): Connection;
+/**
+ * Checks if a connection exists in an array where a concept is either the source or target.
+ *
+ * @param connectionList - Array of connections to search through
+ * @param conceptId - The ID of the concept to find in connections
+ * @returns The first connection found where the concept appears as either toTheConceptId or ofTheConceptId
+ *
+ * @example
+ * ```typescript
+ * const connections = [conn1, conn2, conn3];
+ * const found = CheckIfToTheConceptExistsInConnectionArray(connections, 123);
+ * if (found.id !== 0) {
+ *   console.log('Concept is connected!');
+ * }
+ * ```
+ *
+ * @remarks
+ * This function searches bidirectionally - it finds connections where the concept is either:
+ * - The target (toTheConceptId)
+ * - The source (ofTheConceptId)
+ * If both exist, the ofTheConceptId match takes precedence as it's checked second.
+ * Returns a default connection (all zeros) if no match is found.
+ */
+export declare function CheckIfToTheConceptExistsInConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection;
+/**
+ * Finds all connections in an array where a concept appears as either source or target.
+ *
+ * @param connectionList - Array of connections to search through
+ * @param conceptId - The ID of the concept to find in connections
+ * @returns Array of all connections where the concept is connected (up to 2: one as target, one as source)
+ *
+ * @example
+ * ```typescript
+ * const connections = [conn1, conn2, conn3];
+ * const found = CheckAllConnectionsConnectedInConnectionArray(connections, 123);
+ * console.log(`Concept has ${found.length} connections`);
+ * ```
+ *
+ * @remarks
+ * This function finds connections where the concept appears as:
+ * - toTheConceptId (target/destination of connection)
+ * - ofTheConceptId (source/origin of connection)
+ * Note: Uses `find()` which only returns the first match for each direction,
+ * so maximum 2 connections will be returned even if more exist.
+ *
+ * @see {@link CheckAllConnectionsConnectedInLConnectionArray} for the LConnection variant
+ */
+export declare function CheckAllConnectionsConnectedInConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection[];
+/**
+ * Finds all LConnections (lightweight connections) in an array where a concept appears as either source or target.
+ *
+ * @param connectionList - Array of LConnections to search through
+ * @param conceptId - The ID of the concept to find in connections
+ * @returns Array of all LConnections where the concept is connected (up to 2: one as target, one as source)
+ *
+ * @example
+ * ```typescript
+ * const lconnections = [lconn1, lconn2, lconn3];
+ * const found = CheckAllConnectionsConnectedInLConnectionArray(lconnections, 123);
+ * console.log(`Concept has ${found.length} lightweight connections`);
+ * ```
+ *
+ * @remarks
+ * This is the LConnection variant of CheckAllConnectionsConnectedInConnectionArray.
+ * LConnection is a lightweight representation of connections used for performance optimization.
+ * Like its standard counterpart, it uses `find()` which only returns the first match per direction,
+ * so maximum 2 connections will be returned.
+ *
+ * @see {@link CheckAllConnectionsConnectedInConnectionArray}
+ */
+export declare function CheckAllConnectionsConnectedInLConnectionArray(connectionList: LConnection[] | undefined, conceptId: number): LConnection[];

package/dist/types/Helpers/RemoveFromArray.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Remove From Array Helper Module for Concept Connection System (CCS-JS)
+ *
+ * This module provides utility functions for removing concepts and connections from arrays.
+ * These functions mutate the original arrays by splicing out matching elements by ID.
+ *
+ * @module Helpers/RemoveFromArray
+ * @see https://documentation.freeschema.com for data structure reference
+ */
+import { Concept } from "../DataStructures/Concept";
+import { Connection } from "../DataStructures/Connection";
+import { LConnection } from "../app";
+/**
+ * Removes a concept from an array by matching its ID.
+ *
+ * @param conceptList - Array of concepts to remove from (will be mutated)
+ * @param concept - The concept to remove from the array
+ *
+ * @example
+ * ```typescript
+ * const concepts = [concept1, concept2, concept3];
+ * RemoveConceptFromList(concepts, concept2);
+ * console.log(concepts.length); // 2 (concept2 has been removed)
+ * ```
+ *
+ * @remarks
+ * This function mutates the original array using splice().
+ * If the concept is not found (findIndex returns -1), splice will remove the last element.
+ * Ensure the concept exists in the array before calling this function to avoid unintended removals.
+ */
+export declare function RemoveConceptFromList(conceptList: Concept[] | undefined, concept: Concept): void;
+/**
+ * Removes a connection from an array by matching its ID.
+ *
+ * @param connectionList - Array of connections to remove from (will be mutated)
+ * @param connection - The connection to remove from the array
+ *
+ * @example
+ * ```typescript
+ * const connections = [conn1, conn2, conn3];
+ * RemoveConnectionFromList(connections, conn2);
+ * console.log(connections.length); // 2 (conn2 has been removed)
+ * ```
+ *
+ * @remarks
+ * This function mutates the original array using splice().
+ * If the connection is not found (findIndex returns -1), splice will remove the last element.
+ * Ensure the connection exists in the array before calling this function to avoid unintended removals.
+ */
+export declare function RemoveConnectionFromList(connectionList: Connection[] | undefined, connection: Connection): void;
+/**
+ * Removes an LConnection (lightweight connection) from an array by matching its ID.
+ *
+ * @param connectionList - Array of LConnections to remove from (will be mutated)
+ * @param connection - The LConnection to remove from the array
+ *
+ * @example
+ * ```typescript
+ * const lconnections = [lconn1, lconn2, lconn3];
+ * RemoveLConnectionFromList(lconnections, lconn2);
+ * console.log(lconnections.length); // 2 (lconn2 has been removed)
+ * ```
+ *
+ * @remarks
+ * This is the LConnection variant of RemoveConnectionFromList.
+ * LConnection is a lightweight representation used for performance optimization.
+ * This function mutates the original array using splice().
+ * If the connection is not found (findIndex returns -1), splice will remove the last element.
+ *
+ * @see {@link RemoveConnectionFromList}
+ */
+export declare function RemoveLConnectionFromList(connectionList: LConnection[] | undefined, connection: LConnection): void;

package/dist/types/Helpers/UniqueInsert.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Unique Insert Helper Module for Concept Connection System (CCS-JS)
+ *
+ * This module provides utility functions for inserting values into arrays while ensuring uniqueness.
+ * It prevents duplicate entries by checking if the value already exists before insertion.
+ *
+ * @module Helpers/UniqueInsert
+ * @see https://documentation.freeschema.com for data structure reference
+ */
+/**
+ * Inserts a number into an array only if it doesn't already exist.
+ *
+ * @param Array - Array of numbers to insert into (will be mutated if insertion occurs)
+ * @param toInsert - The number to insert into the array
+ * @returns The modified array with the number inserted (or unchanged if it already existed)
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3];
+ * InsertUniqueNumber(numbers, 4); // [1, 2, 3, 4]
+ * InsertUniqueNumber(numbers, 2); // [1, 2, 3, 4] (2 already exists, no change)
+ * ```
+ *
+ * @remarks
+ * This function mutates the original array by pushing the value if it's not found.
+ * Uses indexOf() for checking existence, which has O(n) time complexity.
+ * For large arrays with frequent insertions, consider using a Set data structure instead.
+ */
+export default function InsertUniqueNumber(Array: number[], toInsert: number): number[];