mftsccs-browser 2.1.242-dev → 2.1.244-dev

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

@@ -0,0 +1,81 @@
+import { Connection } from "../../DataStructures/Connection";
+import { ConnectionNode } from "./ConnectionNode";
+/**
+ * ConnectionBinaryTree — In-memory connection store keyed by numeric connection ID.
+ *
+ * Backed by a Map<number, Connection> for O(1) lookups, inserts, and deletes.
+ * The secondary index trees (ConnectionTypeTree, ConnectionOfTheTree) are
+ * managed separately by ConnectionData and remain unchanged.
+ *
+ * All public method signatures are preserved for backward compatibility.
+ * getNodeFromTree returns a { key, value } wrapper so callers that access
+ * node.value continue to work without changes.
+ */
+export declare class ConnectionBinaryTree {
+    /** Sentinel root — non-null when the map has data, null when empty. */
+    static connectionroot: ConnectionNode | null;
+    /** Primary data store: connection ID → Connection object */
+    private static connectionMap;
+    /**
+     * Low-level add — stores the node's key/value in the Map.
+     * Kept for API compatibility.
+     * @param node - ConnectionNode with numeric key and Connection value
+     */
+    static addNodeToTree(node: ConnectionNode): void;
+    /**
+     * Adds a connection to the Map and dispatches an event for the
+     * owning concept so UI listeners can react.
+     *
+     * The dispatchIdEvent(ofTheConceptId) was previously fired inside
+     * ConnectionNode.addNode when the node was placed into a null slot.
+     * We only fire it for new connections (not overwrites) to preserve
+     * the original behavior.
+     *
+     * @param connection - The Connection to store
+     */
+    static addConnectionToTree(connection: Connection): void;
+    /**
+     * Returns the total number of connections stored.
+     * @returns Number of connections in the Map
+     */
+    static traverse(): number;
+    /**
+     * Polls until IdentifierFlags.isConnectionLoaded is true (max 25 seconds).
+     * Used by callers that need to wait for the initial IndexedDB load to finish.
+     */
+    static waitForDataToLoad(): Promise<unknown>;
+    /** Recursive polling helper for waitForDataToLoad */
+    static checkFlag(resolve: any): any;
+    /**
+     * Removes a connection by ID. Dispatches an event for the owning concept
+     * before deletion so listeners can react to the removal.
+     *
+     * @param id - The connection ID to remove
+     */
+    static removeNodeFromTree(id: number): Promise<void>;
+    /**
+     * Retrieves a connection by ID from the Map.
+     *
+     * Returns a { key, value } wrapper matching the ConnectionNode shape.
+     * Also increments the connection's count field for access tracking
+     * (preserving the original ConnectionNode.getFromNode behavior).
+     *
+     * @param id - The connection ID to look up
+     * @returns ConnectionNode-like wrapper with .value = Connection, or null/undefined
+     */
+    static getNodeFromTree(id: number): Promise<ConnectionNode | null | undefined>;
+    /**
+     * Bulk connection retrieval by ID list.
+     *
+     * For each ID found in the Map, pushes the Connection into connectionArray
+     * and removes the ID from the ids array. IDs remaining after this call
+     * are "not found" and will be fetched from the backend.
+     *
+     * Performance: O(k) where k = ids.length (was O(N) full tree traversal).
+     *
+     * @param ids - Array of connection IDs to look up (mutated: found IDs are spliced out)
+     * @param connectionArray - Output array (mutated: found Connections are pushed)
+     * @param remainingIds - Not used directly but kept for API compatibility
+     */
+    static getConnectionListFromIds(ids: number[], connectionArray: Connection[], remainingIds: any): Promise<void>;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionNode.d.ts

@@ -0,0 +1,27 @@
+import { Connection } from "./../Connection";
+export declare class ConnectionNode {
+    key: any;
+    value: Connection;
+    leftNode: ConnectionNode | null;
+    rightNode: ConnectionNode | null;
+    currentNode: ConnectionNode | null;
+    variants: ConnectionNode[];
+    height: number;
+    constructor(key: any, value: Connection, leftNode: ConnectionNode | null, rightNode: ConnectionNode | null);
+    addCurrentNode(passedNode: ConnectionNode, node: ConnectionNode | null): ConnectionNode;
+    addCurrentNodeType(passedNode: ConnectionNode, node: ConnectionNode | null): ConnectionNode;
+    getMax(a: number, b: number): number;
+    addNode(passedNode: ConnectionNode, node: ConnectionNode | null, height: number): ConnectionNode | null;
+    addTypeNode(passedNode: ConnectionNode, node: ConnectionNode | null, height: number): ConnectionNode | null;
+    rightRotate(y: ConnectionNode | null): ConnectionNode | null;
+    leftRotate(x: ConnectionNode | null): ConnectionNode | null;
+    getHeight(node: ConnectionNode | null): number;
+    getBalanceFactor(N: ConnectionNode | null): number;
+    getFromNode(id: number, node: ConnectionNode | null): ConnectionNode | null;
+    getCharacterFromNode(value: string, node: ConnectionNode | null): ConnectionNode | null;
+    checkIfIdsInNode(node: ConnectionNode | null, ids: number[], connectionArray: Connection[], remainingIds: any): void;
+    traverse(node: ConnectionNode | null): number;
+    removeNode(passedNode: ConnectionNode | null, id: number): ConnectionNode | null;
+    removeNodeWithVariants(passedNode: ConnectionNode | null, typeIdentifier: any, conceptId: number): ConnectionNode | null;
+    inOrderSuccessor(root: ConnectionNode): ConnectionNode;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionOfNode.d.ts

@@ -0,0 +1,10 @@
+import { NodePrimitive } from "./NodePrimitive";
+export declare class ConnectionOfNode extends NodePrimitive {
+    key: string;
+    value: number[];
+    height: number;
+    leftNode: ConnectionOfNode | null;
+    rightNode: ConnectionOfNode | null;
+    constructor(key: any, value: number[], leftNode: ConnectionOfNode | null, rightNode: ConnectionOfNode | null);
+    addNode(passedNode: ConnectionOfNode, node: ConnectionOfNode | null, height: number): any;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionOfTheTree.d.ts

@@ -0,0 +1,24 @@
+import { Connection } from "../Connection";
+import { ConnectionOfNode } from "./ConnectionOfNode";
+/**
+ * This is a binary tree that is used to store the reference to the main connection of the concept.
+ */
+export declare class ConnectionOfTheTree {
+    static node: ConnectionOfNode | null;
+    static CreateCompositionKey(ofTheConceptId: number, typeId: number): number;
+    static GetConnectionByOfTheConceptAndTypeId(ofTheConceptId: number, typeId: number): any;
+    /**
+     * This function lets you add a connection by composite key with of the concept id and type id.
+     * This function checks if the connection already exists and then updates in the case that it does not
+     * If the connection of the concept id and type id combination is encountered first time then a node is created.
+     * @param connection connection that needs to be added.
+     */
+    static addConnection(connection: Connection): void;
+    /**
+     * This is a function to add the connectionNode to the existing tree
+     * @param connectionOfNode This is the node that needs to be added to the tree.
+     * @returns ConnectionOfNode
+     */
+    static addNodeToTree(connectionOfNode: ConnectionOfNode): Promise<ConnectionOfNode | null>;
+    static removeNodeFromTree(id: number): Promise<void>;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionTypeNode.d.ts

@@ -0,0 +1,10 @@
+import { NodePrimitive } from "./NodePrimitive";
+export declare class ConnectionTypeNode extends NodePrimitive {
+    key: string;
+    value: number[];
+    height: number;
+    leftNode: ConnectionTypeNode | null;
+    rightNode: ConnectionTypeNode | null;
+    constructor(key: any, value: number[], leftNode: ConnectionTypeNode | null, rightNode: ConnectionTypeNode | null);
+    addNode(passedNode: ConnectionTypeNode, node: ConnectionTypeNode | null, height: number): any;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionTypeTree.d.ts

@@ -0,0 +1,20 @@
+import { Connection } from "../../DataStructures/Connection";
+import { ConnectionTypeNode } from "./ConnectionTypeNode";
+export declare class ConnectionTypeTree {
+    static connectionTypeRoot: ConnectionTypeNode | null;
+    static CreateCompositionKey(typeId: number): number;
+    /**
+     * This is a function to add the connectionNode to the existing tree
+     * @param connectionOfNode This is the node that needs to be added to the tree.
+     * @returns ConnectionOfNode
+     */
+    static addNodeToTree(connectionOfNode: ConnectionTypeNode): Promise<ConnectionTypeNode | null>;
+    /**
+     * This function lets you add a connection by composite key with of the concept id and type id.
+     * This function checks if the connection already exists and then updates in the case that it does not
+     * If the connection of the concept id and type id combination is encountered first time then a node is created.
+     * @param connection connection that needs to be added.
+     */
+    static addConnectionToTree(connection: Connection): void;
+    static GetConnectionByOfTheConceptAndTypeId(ofTheConceptId: number, typeId: number): any;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/NodePrimitive.d.ts

@@ -0,0 +1,15 @@
+export declare class NodePrimitive {
+    key: string;
+    value: number[];
+    height: number;
+    leftNode: any | null;
+    rightNode: any | null;
+    constructor(key: any, value: number[], leftNode: NodePrimitive | null, rightNode: NodePrimitive | null);
+    getFromNode(id: any, node: any | null): any | null;
+    rightRotate(y: NodePrimitive | null): any;
+    leftRotate(x: NodePrimitive | null): any;
+    getHeight(node: NodePrimitive | null): number;
+    getBalanceFactor(N: NodePrimitive | null): number;
+    removeNode(passedNode: any | null, id: number): any;
+    inOrderSuccessor(root: any): any;
+}

package/dist/types/DataStructures/ConnectionByType/GetConnectionByType.d.ts

@@ -0,0 +1,4 @@
+export declare class GetConnectionsByTypes {
+    ofTheConceptId: number;
+    connectionTypes: string[];
+}

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

@@ -0,0 +1,26 @@
+import { Connection } from "./Connection";
+export declare class ConnectionData {
+    name: string;
+    constructor();
+    static deletedConnections: number[];
+    static connectionArray: Connection[];
+    static connectionDictionary: Connection[];
+    static CheckContains(connection: Connection): boolean;
+    static AddConnectionToStorage(connection: Connection): void;
+    static AddNpConn(id: number): void;
+    static GetNpConn(id: number): boolean;
+    static AddConnection(connection: Connection): void;
+    static AddConnectionToMemory(connection: Connection): void;
+    static AddToDictionary(connection: Connection): void;
+    static RemoveConnection(connection: Connection): void;
+    static GetConnectionTypeOfTree(): void;
+    static GetConnectionByOfTheConceptAndType(ofTheConceptId: number, typeId: number): Promise<any>;
+    static GetConnectionByOfType(ofTheConceptId: number, typeId: number): any;
+    static GetConnectionTree(): import("./ConnectionBinaryTree/ConnectionNode").ConnectionNode | null;
+    static GetConnectionTypeTree(): import("./ConnectionBinaryTree/ConnectionTypeNode").ConnectionTypeNode | null;
+    static GetConnectionBulkData(ids: number[], connectionArray: Connection[], remainingIds: any): Promise<void>;
+    static GetConnection(id: number): Promise<any>;
+    static GetConnectionsOfCompositionLocal(id: number): Promise<any>;
+    static GetConnectionsOfConcept(id: number): Promise<any>;
+    getName(): string;
+}

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

@@ -0,0 +1,6 @@
+export declare class CountInfo {
+    conceptId: number;
+    connectionTypeId: number;
+    connectionType: string;
+    count: number;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * Request/response shape for the POST /api/get-connection-between endpoint.
+ *
+ * Use only the fields relevant to your query permutation and leave the rest at their
+ * zero/empty defaults. The backend resolves `typeId` from the `type` string when
+ * `typeId` is 0, so you never need to supply both.
+ *
+ * **Query permutations:**
+ * 1. `ofTheConceptId` + `toTheConceptId` + `type` — connections between two specific concepts of that type
+ * 2. `ofTheConceptId` + `type`                    — all connections FROM a concept of that type
+ * 3. `toTheConceptId` + `type`                    — all connections TO a concept of that type
+ * 4. `typeId` + `isComposition: true`             — all internal connections of a composition
+ *
+ * After the request, the backend populates `connectionIds` and the resolved `typeId`
+ * on each item and returns the same array.
+ */
+export interface FetchConnection {
+    /** Source concept ID. 0 means "not specified". */
+    ofTheConceptId: number;
+    /** Target concept ID. 0 means "not specified". */
+    toTheConceptId: number;
+    /** Resolved type concept ID. Set directly or leave 0 — backend resolves it from `type`. */
+    typeId: number;
+    /** Human-readable type string (e.g. "the_project_s_page"). Used when typeId is 0. */
+    type: string;
+    /** Legacy type string resolved relative to the source concept's type. Leave empty unless required. */
+    oldType: string;
+    /** When true, searches for connections in the reverse direction (toTheConceptId → ofTheConceptId). */
+    reverse: boolean;
+    /** When true, treats typeId as a composition ID and returns its internal connections. */
+    isComposition: boolean;
+    /** Populated by the backend after the request — the matching connection IDs. */
+    connectionIds: number[];
+}
+/**
+ * Input-only shape for building a FetchConnection query.
+ * Omits `connectionIds` since that is an output field populated by the backend.
+ */
+export type FetchConnectionQuery = Omit<FetchConnection, 'connectionIds'>;
+/**
+ * Builds a complete FetchConnection request object from a partial query,
+ * filling unspecified fields with their zero/empty defaults.
+ *
+ * Use this instead of constructing FetchConnection manually so you only
+ * need to specify the fields relevant to your query permutation.
+ *
+ * @param query - Partial query with only the fields you need.
+ * @returns A fully initialised FetchConnection ready to send to the API.
+ *
+ * @example
+ * // Between two concepts
+ * buildFetchConnection({ ofTheConceptId: 1, toTheConceptId: 2, type: "the_project_s_page" })
+ *
+ * @example
+ * // All connections from a concept
+ * buildFetchConnection({ ofTheConceptId: 1, type: "the_project_s_page" })
+ *
+ * @example
+ * // All internal connections of a composition
+ * buildFetchConnection({ typeId: 101490186, isComposition: true })
+ *
+ * @see {@link GetConnectionsBetweenApi} to send the built query to the backend
+ */
+export declare function buildFetchConnection(query: Partial<FetchConnectionQuery>): FetchConnection;

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

@@ -0,0 +1,9 @@
+export declare class FilterSearch {
+    type: string;
+    search: string;
+    logicoperator: string;
+    index: number;
+    composition: boolean;
+    name: string;
+    operateon: string;
+}

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

@@ -0,0 +1,11 @@
+export declare class IdentifierFlags {
+    static isTypeLoaded: boolean;
+    static isCharacterLoaded: boolean;
+    static isDataLoaded: boolean;
+    static isLocalDataLoaded: boolean;
+    static isLocalCharacterLoaded: boolean;
+    static isLocalTypeLoaded: boolean;
+    static isConnectionLoaded: boolean;
+    static isConnectionTypeLoaded: boolean;
+    static isLocalConnectionLoaded: boolean;
+}

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

@@ -0,0 +1,23 @@
+import { Concept } from "../Concept";
+export declare class LConcept {
+    id: number;
+    structureType: string;
+    ghostId: number;
+    userId: number;
+    typeId: number;
+    categoryId: number;
+    accessId: number;
+    characterValue: string;
+    typeCharacter: string;
+    entryTimeStamp: Date;
+    referentId: number;
+    updatedTimeStamp: Date;
+    type: LConcept | null | void | Concept;
+    isNew: boolean;
+    isComposition: boolean;
+    isTemp: boolean;
+    isSynced: boolean;
+    applicationId: number;
+    constructor(id: number, userId: number, typeId: number, categoryId: number, accessId: number, characterValue: string, typeCharacter: string, isNew: boolean | undefined, entryTimeStamp: Date, updatedTimeStamp: Date, referentId: number);
+    getType(): void;
+}

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

@@ -0,0 +1,18 @@
+import { Concept } from "../Concept";
+export declare class LConnection {
+    id: number;
+    ghostId: number;
+    ofTheConceptId: number;
+    toTheConceptId: number;
+    entryTimeStamp: Date | string;
+    terminationDateTime: Date;
+    accessId: number;
+    typeId: number;
+    orderId: number;
+    typeCharacter: string;
+    localSyncTime: Date;
+    isTemp: boolean;
+    applicationId: number;
+    type: Concept;
+    constructor(id: number, ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId: number, accessId: number);
+}

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

@@ -0,0 +1,29 @@
+import { Concept } from "./../Concept";
+export declare class LNode {
+    key: any;
+    value: Concept;
+    leftNode: LNode | null;
+    rightNode: LNode | null;
+    currentNode: LNode | null;
+    variants: LNode[];
+    height: number;
+    constructor(key: any, value: Concept, leftNode: LNode | null, rightNode: LNode | null);
+    addCurrentNode(passedNode: LNode, node: LNode | null): LNode;
+    addCurrentNodeType(passedNode: LNode, node: LNode | null): LNode;
+    addNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    addCharacterNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    addTypeNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    rightRotate(y: LNode | null): LNode | null;
+    leftRotate(x: LNode | null): LNode | null;
+    getHeight(node: LNode | null): number;
+    getBalanceFactor(N: LNode | null): number;
+    getFromNode(id: number, node: LNode | null): LNode | null;
+    updateNodeSyncStatus(id: number, value: any, node: LNode | null): LNode | null;
+    getCharacterFromNode(value: string, node: LNode | null): LNode | null;
+    getFromNodeWithCharacterAndType(value: string, typeId: number, node: LNode | null): LNode | null;
+    getFromNodeWithCharacterAndCategory(value: string, categoryId: number, node: LNode | null): LNode | null;
+    removeNode(passedNode: LNode | null, id: number): LNode | null;
+    removeNodeWithVariants(passedNode: LNode | null, typeIdentifier: any, conceptId: number): LNode | null;
+    countNodeBelow(root: LNode | null): number;
+    inOrderSuccessor(root: LNode): LNode;
+}

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

@@ -0,0 +1,13 @@
+import { Concept } from "../../DataStructures/Concept";
+import { LNode } from "./../Local/LNode";
+export declare class LocalBinaryCharacterTree {
+    static LocalCharacterRoot: LNode | null;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static addNodeToTree(node: LNode): Promise<LNode | null>;
+    static addConceptToTree(concept: Concept): void;
+    static getNodeFromTree(value: string): LNode | null;
+    static getCharacterAndTypeFromTree(value: string, typeId: number): Promise<LNode | null>;
+    static getCharacterAndCategoryFromTree(value: string, categoryId: number): Promise<LNode | null>;
+    static removeConceptType(character: string, id: number): void;
+}

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

@@ -0,0 +1,13 @@
+import { Concept } from "../../DataStructures/Concept";
+import { LNode } from "./../Local/LNode";
+export declare class LocalBinaryTree {
+    static root: LNode | null;
+    static addNodeToTree(node: LNode): LNode | undefined;
+    static addConceptToTree(concept: Concept): void;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static getNodeFromTree(id: number): Promise<LNode | null>;
+    static getCharacterAndTypeFromTree(value: string, typeId: number): LNode | null;
+    static updateSyncStatus(id: number): LNode | null;
+    static removeNodeFromTree(id: number): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import { Concept } from "../../DataStructures/Concept";
+import { LNode } from "./LNode";
+export declare class LocalBinaryTypeTree {
+    static LocalTypeRoot: LNode | null;
+    static addNodeToTree(node: LNode): Promise<LNode | null>;
+    static addConceptToTree(concept: Concept): void;
+    static removeConceptType(typeId: number, id: number): void;
+    static getNodeFromTree(id: number): LNode | null;
+    static getTypeVariantsFromTree(typeId: number): Concept[] | undefined;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static getTypeVariantsFromTreeWithUserId(typeId: number, userId: number): Promise<Concept[]>;
+}

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

@@ -0,0 +1,21 @@
+import { Concept } from "./../Concept";
+export declare class LocalConceptsData {
+    name: string;
+    constructor();
+    static localconceptsArray: Concept[];
+    static AddConcept(concept: Concept): void;
+    static AddPermanentConcept(concept: Concept): void;
+    static RemoveConcept(concept: Concept): Promise<void>;
+    static RemoveConceptById(conceptId: number): Promise<void>;
+    static AddConceptToMemory(concept: Concept): void;
+    static GetConcept(id: number): Promise<Concept>;
+    static UpdateConceptSyncStatus(id: number): Promise<void>;
+    static GetConceptByGhostId(id: number): Promise<Concept>;
+    static GetConceptByCharacter(characterValue: string): Promise<Concept>;
+    static GetConceptByCharacterAndTypeLocal(character_value: string, typeId: number): Promise<Concept>;
+    static GetConceptByCharacterAndCategoryLocal(character_value: string, categoryId: number): Promise<Concept>;
+    static GetConceptsByTypeId(typeId: number): Concept[];
+    static GetConceptsByTypeIdAndUser(typeId: number, userId: number): Promise<Concept[]>;
+    static ClearData(): Promise<void>;
+    getName(): string;
+}

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

@@ -0,0 +1,20 @@
+import { Connection } from "../Connection";
+export declare class LocalConnectionData {
+    name: string;
+    constructor();
+    static connectionArray: Connection[];
+    static connectionDictionary: Connection[];
+    static CheckContains(connection: Connection): boolean;
+    static AddConnection(connection: Connection): void;
+    static AddConnectionToMemory(connection: Connection): void;
+    static AddToDictionary(connection: Connection): void;
+    static RemoveConnection(connection: Connection): void;
+    static RemoveConnectionById(connectionId: number): void;
+    static AddPermanentConnection(connection: Connection): void;
+    static GetConnection(id: number): Connection | null;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static GetConnectionsOfCompositionLocal(id: number): Promise<Connection[]>;
+    static GetConnectionOfCompositionAndTypeLocal(typeId: number, ofTheConceptId: number): Promise<Connection[]>;
+    getName(): string;
+}

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

@@ -0,0 +1,11 @@
+import { Concept } from "../../DataStructures/Concept";
+import { LNode } from "./../Local/LNode";
+export declare class LocalGhostIdTree {
+    static root: LNode | null;
+    static addNodeToTree(node: LNode): LNode | undefined;
+    static addConceptToTree(concept: Concept): void;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static getNodeFromTree(id: number): Promise<LNode | null>;
+    static removeNodeFromTree(id: number): Promise<void>;
+}

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

@@ -0,0 +1,19 @@
+export declare class LocalId {
+    static localId: number;
+    static localConnectionId: number;
+    static ReservedLocalId: number[];
+    static ReservedConnectionId: number[];
+    static AddConceptId(id: any): void;
+    /**
+     *
+     * This function will get the local concept id from the indexdb
+     * @returns the local concept id
+     */
+    static getConceptId(): Promise<number>;
+    /**
+     *
+     * @param object This is the object that needs to be updated
+     */
+    static AddConnectionId(object: any): void;
+    static getConnectionId(): Promise<number>;
+}

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

@@ -0,0 +1,33 @@
+import { Concept } from "./../Concept";
+import { Connection } from "../Connection";
+import { InnerActions } from "../../app";
+type syncContainer = {
+    id: string;
+    data: InnerActions;
+    createdDate: string;
+};
+export declare class LocalSyncData {
+    static conceptsSyncArray: Concept[];
+    static connectionSyncArray: Connection[];
+    static ghostIdMap: Map<any, any>;
+    static transactionCollections: syncContainer[];
+    static CheckContains(concept: Concept): boolean;
+    static SyncDataDelete(id: number): void;
+    static CheckContainsConnection(connection: Connection): boolean;
+    static AddConcept(concept: Concept): void;
+    static RemoveConcept(concept: Concept): void;
+    static SyncDataOnlineWithoutAuth(transactionId?: string, actions?: InnerActions, withAuth?: boolean): Promise<any>;
+    static SyncDataOnline(transactionId?: string, actions?: InnerActions, withAuth?: boolean): Promise<any>;
+    static ConvertGhostIdsInConnections(connectionArray: Connection[]): void;
+    static UpdateConceptListToIncludeRelatedConcepts(connectionArray: Connection[], conceptsArray: Concept[]): Promise<void>;
+    static AddConceptIfDoesNotExist(concept: Concept, conceptList?: Concept[]): void;
+    static CheckIfTheConceptIdExists(id: number, conceptList?: Concept[]): Concept;
+    static AddConnection(connection: Connection): void;
+    static RemoveConnection(connection: Connection): void;
+    static RemoveConnectionById(connectionId: number): void;
+    static syncDataLocalDb(): Promise<string>;
+    static initializeTransaction(transactionId: string): Promise<any>;
+    static markTransactionActions(transactionId: string, actions: InnerActions): Promise<any>;
+    static rollbackTransaction(transactionId: string, actions: InnerActions): Promise<any>;
+}
+export {};

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

@@ -0,0 +1,30 @@
+import { Concept } from "./Concept";
+export declare class Node {
+    key: any;
+    value: Concept;
+    leftNode: Node | null;
+    rightNode: Node | null;
+    currentNode: Node | null;
+    variants: Node[];
+    height: number;
+    constructor(key: any, value: Concept, leftNode: Node | null, rightNode: Node | null);
+    addCurrentNode(passedNode: Node, node: Node | null): Node;
+    addCurrentNodeType(passedNode: Node, node: Node | null): Node;
+    addNode(passedNode: Node, node: Node | null, height: number): Node | null;
+    checkIfIdsInNode(node: Node | null, ids: number[], connectionArray: Concept[], remainingIds: any): void;
+    addCharacterNode(passedNode: Node, node: Node | null, height: number): Node | null;
+    addTypeNode(passedNode: Node, node: Node | null, height: number): Node | null;
+    rightRotate(y: Node | null): Node | null;
+    leftRotate(x: Node | null): Node | null;
+    getHeight(node: Node | null): number;
+    getBalanceFactor(N: Node | null): number;
+    getFromNode(id: number, node: Node | null): Node | null;
+    getCharacterFromNode(value: string, node: Node | null): Node | null;
+    getCharacterFromNodeUpdated(value: string, node: Node | null): Node | null;
+    getFromNodeWithCharacterAndType(value: string, typeId: number, node: Node | null): Node | null;
+    getFromNodeWithCharacterAndCategory(value: string, categoryId: number, node: Node | null): Node | null;
+    removeNode(passedNode: Node | null, id: number): Node | null;
+    removeNodeWithVariants(passedNode: Node | null, typeIdentifier: any, conceptId: number): Node | null;
+    countNodeBelow(root: Node | null): number;
+    inOrderSuccessor(root: Node): Node;
+}

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

@@ -0,0 +1,8 @@
+export declare class PatcherStructure {
+    compositionId: number;
+    userId: number;
+    sessionId: number;
+    accessId: number;
+    ofTheCompositionId: number;
+    patchObject: any;
+}

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

@@ -0,0 +1,19 @@
+import { Concept } from "../Concept";
+import { Connection } from "../Connection";
+import { PrototypeOption } from "./PrototypeOption";
+import { QuerySelector } from "./QuerySelector";
+export declare class Prototype {
+    prototype: string;
+    required: string[];
+    optional: string[];
+    field: string;
+    childPrototypes: Prototype[];
+    isCompositional: boolean;
+    options: PrototypeOption[];
+    isQueryType: boolean;
+    querySelector: QuerySelector | null;
+    concepts: Concept[];
+    connections: Connection[];
+    addedConcepts: Concept[];
+    addedConnections: Connection[];
+}

package/dist/types/DataStructures/Prototype/PrototypeOption.d.ts

@@ -0,0 +1,4 @@
+export declare class PrototypeOption {
+    type: string;
+    value: string;
+}

package/dist/types/DataStructures/Prototype/QuerySelector.d.ts

@@ -0,0 +1,4 @@
+export declare class QuerySelector {
+    filterType: string;
+    selector: string;
+}

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

@@ -0,0 +1,10 @@
+export declare class ReservedIds {
+    static ids: number[];
+    static getId(): Promise<number>;
+    static AddId(id: number): void;
+}
+export declare class ReservedConnectionIds {
+    static connectionIds: number[];
+    static getId(): Promise<number>;
+    static AddId(id: number): void;
+}