mftsccs-browser 2.1.242-dev → 2.1.243-dev

package/dist/types/Services/Search/SearchWithTypeAndLinker.d.ts

@@ -0,0 +1,82 @@
+import { SearchStructure, SearchQuery } from '../../app';
+import { CountInfo } from '../../DataStructures/Count/CountInfo';
+/**
+ * This function will help you search a concept by their type and also to query inside of it.
+ * Put the number of compositions you want to get in the searchStructure which can be set by inpage and page
+ * Then the type should be set in searchQuery for the compositionName.
+ * Inside the searchQuery array this you can set the full linker / listLinker in the searchQuery.
+ * This will give the id of the structures.
+ */
+export declare function SearchWithTypeAndLinkerDataId(searchStructure: SearchStructure, searchQuery: SearchQuery[], token?: string): Promise<any>;
+/**
+ * This function will help you search a concept by their type and also to query inside of it.
+ * Put the number of compositions you want to get in the searchStructure which can be set by inpage and page
+ * Then the type should be set in searchQuery for the compositionName.
+ * Inside the searchQuery array this you can set the full linker / listLinker in the searchQuery.
+ * This will not give the id of the structures.
+ */
+export declare function SearchWithTypeAndLinker(searchStructure: SearchStructure, searchQuery: SearchQuery[], token?: string): Promise<any>;
+/**
+ * ## Format dataid ##
+ * @param linkers
+ * @param conceptIds
+ * @param connections
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatDataArrayDataId(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
+/**
+ * ## Format Normal ##
+ * @param linkers
+ * @param conceptIds
+ * @param connections
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatDataArrayNormal(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
+/**
+ * ## Format Normal ##
+ * @param linkers
+ * @param conceptIds
+ * @param connections
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatLinkersNormal(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
+/**
+ * ## Format Normal ##
+ * This function fetches all the connections and then converts all the connections to the single level connections
+ * Then those single level objects are then stiched together to create a complex json/ array.
+ * @param linkers
+ * @param conceptIds
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatConnections(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[]): Promise<any>;
+/**
+ * ## Format JustId ##
+ * This function fetches all the connections and then converts all the connections to the single level connections
+ * Then those single level objects are then stiched together to create a complex json/ array.
+ * @param linkers
+ * @param conceptIds
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatConnectionsJustId(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;
+/**
+ * ## Format DATA-ID ##
+ * This function fetches all the connections and then converts all the connections to the single level connections
+ * Then those single level objects are then stiched together to create a complex json/ array.
+ * @param linkers
+ * @param conceptIds
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatConnectionsDataId(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;
+export declare function formatConnectionsV2(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;

package/dist/types/Services/Search/orderingConnections.d.ts

@@ -0,0 +1,2 @@
+import { Connection } from "../../app";
+export declare function orderTheConnections(connections: Connection[], order?: string): Connection[];

package/dist/types/Services/Security/GetRequestHeader.d.ts

@@ -0,0 +1,7 @@
+type RequestHeader = Record<string, string>;
+export declare function GetRequestHeader(contentType?: string, Accept?: string): Promise<RequestHeader>;
+export declare function GetRequestHeaderWithAuthorization(contentType?: string, token?: string, Accept?: string): Promise<RequestHeader>;
+export declare function GetOnlyTokenHeader(): Promise<Headers>;
+export declare function fetchWithAuthRetry(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export declare function getValidAccessToken(token?: string): Promise<string>;
+export {};

package/dist/types/Services/SplitStrings.d.ts

@@ -0,0 +1 @@
+export declare function SplitStrings(typeString: string): string[];

package/dist/types/Services/Transaction/LocalTransaction.d.ts

@@ -0,0 +1,117 @@
+import { Concept, InnerActions } from "../../app";
+import { FetchConnectionQuery } from "../../DataStructures/FetchConnection";
+export declare class LocalTransaction {
+    protected transactionId: string;
+    actions: InnerActions;
+    protected success: boolean;
+    protected pendingConnectionDeletions: number[];
+    constructor();
+    /**
+     * Method to initialize the transactions for specified transaction
+     */
+    initialize(): Promise<void>;
+    /**
+     * Method to commi the created Transactions
+     */
+    commitTransaction(): Promise<void>;
+    commitTransactionWithoutAuth(): Promise<void>;
+    /**
+     * Method to rollback all the tranctions occured
+     */
+    rollbackTransaction(): Promise<void>;
+    /**
+     * Method to move concepts and connection to transaction collection
+     * @param concept Concept
+     */
+    protected markAction(): Promise<void>;
+    /**
+     * Deletions
+     */
+    /**
+     * Queries the backend for connections matching the given criteria and queues all
+     * returned connection IDs for bulk deletion when commitTransaction() is called.
+     *
+     * **Nothing is deleted until commitTransaction() is called.**
+     * Calling rollbackTransaction() discards the queue without touching the backend.
+     *
+     * Supported query permutations:
+     * 1. `ofTheConceptId` + `toTheConceptId` + `type` — connections between two specific concepts
+     * 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
+     *
+     * For multiple queries in one go use {@link DeleteConnectionsBetweenBulk} — it sends
+     * all queries in a single HTTP request.
+     *
+     * @param query - Partial FetchConnectionQuery with only the fields relevant to your permutation.
+     * @returns The connection IDs queued for deletion by this call.
+     *
+     * @example
+     * // Delete all connections of type "the_project_s_page" from concept 103927382
+     * const ids = await transaction.DeleteConnectionsBetween({
+     *     ofTheConceptId: 103927382,
+     *     type: "the_project_s_page"
+     * });
+     * await transaction.commitTransaction(); // deletion fires here
+     *
+     * @example
+     * // Delete connections between two specific concepts
+     * await transaction.DeleteConnectionsBetween({
+     *     ofTheConceptId: 103927382,
+     *     toTheConceptId: 103927389,
+     *     type: "the_project_s_page"
+     * });
+     *
+     * @example
+     * // Delete all internal connections of a composition
+     * await transaction.DeleteConnectionsBetween({
+     *     typeId: 101490186,
+     *     isComposition: true
+     * });
+     *
+     * @see {@link DeleteConnectionsBetweenBulk} for sending multiple queries in one HTTP request
+     * @see {@link commitTransaction} where the queued deletions are executed via bulk delete
+     */
+    DeleteConnectionsBetween(query: Partial<FetchConnectionQuery>): Promise<number[]>;
+    /**
+     * Same as {@link DeleteConnectionsBetween} but resolves multiple queries in a single
+     * HTTP request to POST /api/get-connection-between.
+     *
+     * Prefer this over looping DeleteConnectionsBetween — all queries go to the backend
+     * in one round trip, and all returned IDs are merged into the same pending-deletion queue.
+     * The actual deletion still fires as a single bulk call inside commitTransaction().
+     *
+     * @param queries - Array of partial FetchConnectionQuery objects, one per query permutation.
+     * @returns All connection IDs queued for deletion across every query in this call.
+     *
+     * @example
+     * // Three different queries → one HTTP request to get IDs → one bulk delete on commit
+     * await transaction.DeleteConnectionsBetweenBulk([
+     *     { ofTheConceptId: 103927382, type: "the_project_s_page" },
+     *     { ofTheConceptId: 103927382, type: "the_project_s_tag" },
+     *     { typeId: 101490186, isComposition: true },
+     * ]);
+     * await transaction.commitTransaction();
+     *
+     * @see {@link DeleteConnectionsBetween} for the single-query convenience wrapper
+     * @see {@link commitTransaction} where the queued deletions are executed via bulk delete
+     */
+    DeleteConnectionsBetweenBulk(queries: Partial<FetchConnectionQuery>[]): Promise<number[]>;
+    /**
+     * Concepts
+     */
+    MakeTheInstanceConceptLocal(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number): Promise<any>;
+    MakeTheTypeConceptLocal(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<Concept>;
+    CreateTheConceptLocal(referent: string, typecharacter: string, userId: number, categoryId: number, typeId: number, accessId: number, isComposition?: boolean, referentId?: number | null, actions?: InnerActions): Promise<any>;
+    /**
+     * Connections
+     */
+    CreateConnectionBetweenTwoConceptsLocal(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean): Promise<any>;
+    CreateTheConnectionLocal(ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId?: number, typeString?: string, userId?: number): Promise<any>;
+    CreateConnection(ofTheConcept: Concept, toTheConcept: Concept, connectionTypeString: string): Promise<any>;
+    CreateConnectionBetweenEntityLocal(concept1Data: Concept, concept2Data: Concept, linker: string): Promise<any>;
+    /**
+     * Compositions
+     */
+    CreateTheCompositionLocal(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null, automaticSync?: boolean): Promise<any>;
+}

package/dist/types/Services/UpdateComposition.d.ts

@@ -0,0 +1,2 @@
+import { PatcherStructure } from "../DataStructures/PatcherStructure";
+export default function UpdateComposition(patcherStructure: PatcherStructure): Promise<any>;

package/dist/types/Services/Upload.d.ts

@@ -0,0 +1,111 @@
+export declare const validImageFormats: string[];
+export declare const validDocumentFormats: string[];
+export interface R2UploadData {
+    key: string;
+    bucket: string;
+    contentType: string;
+    size: number;
+    eTag: string;
+    url: string;
+}
+export interface R2PresignedUploadUrlRequest {
+    fileName: string;
+    contentType: string;
+    folder?: string;
+    expiresInSeconds?: number;
+}
+export interface R2PresignedUploadUrlData {
+    uploadUrl: string;
+    key: string;
+    bucket: string;
+    contentType: string;
+    expiresInSeconds: number;
+    expiresAt: string;
+    publicUrl: string;
+}
+export interface R2PresignedUploadOptions {
+    fileName?: string;
+    contentType?: string;
+    folder?: string;
+    expiresInSeconds?: number;
+}
+export interface R2PresignedUploadResult {
+    message: string;
+    success: boolean;
+    url?: string;
+    data?: R2PresignedUploadUrlData;
+    eTag?: string | null;
+}
+export interface UploadResponse<T = string | R2UploadData> {
+    message: string;
+    success: boolean;
+    data?: T;
+}
+type UploadFileParam = Blob & {
+    name?: string;
+    type?: string;
+    uri?: string;
+};
+/**
+ * Generic method to upload file or image
+ * @param file File
+ * @returns Promise<{message: string, success: boolean, url?: string}>
+ */
+export declare function uploadAttachment(file: File, token?: string): Promise<{
+    message: string;
+    success: boolean;
+    url?: string;
+}>;
+/**
+ * Method to upload a file or image to R2 storage.
+ * @param body FormData. Append the file under the "file" key.
+ * @param token string?
+ * @returns UploadResponse<R2UploadData> | null
+ */
+export declare function uploadR2Storage(body: FormData, token?: string): Promise<UploadResponse<R2UploadData> | null>;
+/**
+ * Method to request an R2 pre-signed upload URL from the backend.
+ * @param body Request metadata for the file to upload.
+ * @param token string?
+ * @returns UploadResponse<R2PresignedUploadUrlData> | null
+ */
+export declare function getR2PresignedUploadUrl(body: R2PresignedUploadUrlRequest, token?: string): Promise<UploadResponse<R2PresignedUploadUrlData> | null>;
+/**
+ * Method to upload a file body to a pre-signed R2 URL.
+ * @param uploadUrl URL returned by getR2PresignedUploadUrl
+ * @param file Blob/File, raw body, or compatible file-like object
+ * @param contentType Must match the contentType used when creating the signed URL.
+ * @returns Response from R2
+ */
+export declare function uploadToR2PresignedUrl(uploadUrl: string, file: UploadFileParam | Blob | BodyInit | any, contentType: string): Promise<Response>;
+/**
+ * Full R2 pre-signed upload workflow: create URL, PUT file to R2, return public URL.
+ * @param file Blob/File, raw body, or compatible file-like object
+ * @param options Optional fileName/contentType/folder/expiresInSeconds overrides.
+ * @param token string?
+ * @returns R2PresignedUploadResult
+ */
+export declare function uploadWithR2PresignedUrl(file: UploadFileParam | Blob | BodyInit | any, options?: R2PresignedUploadOptions, token?: string): Promise<R2PresignedUploadResult>;
+/**
+ * Method to upload image to server
+ * @param body FormData
+ * @param token string?
+ * @returns JSON | string | null
+ */
+export declare function uploadImage(body: FormData, token?: string): Promise<R2PresignedUploadResult>;
+/**
+ * Method to upload image to server
+ * @param body FormData
+ * @param token string?
+ * @returns JSON | string | null
+ */
+export declare function uploadImageV2(body: FormData, token?: string): Promise<UploadResponse<string | R2UploadData> | null>;
+/**
+ * Method to upload file to server
+ * @param body FormData
+ * @param token string?
+ * @returns JSON | string | null
+ */
+export declare function uploadFile(body: FormData, token?: string): Promise<UploadResponse<R2UploadData> | null>;
+export declare function getUploadFileLimit(): Promise<{}>;
+export {};

package/dist/types/Services/User/UserFromLocalStorage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns user details synchronously.
+ * Priority: in-memory profileCache (encrypted) → legacy localStorage("profile") fallback.
+ */
+export declare function getUserDetails(): Record<string, any>;
+/**
+ * Returns user details after hydrating storage and refreshing an expired token.
+ * Use this when callers need a valid token from the user details object.
+ */
+export declare function getUserDetailsWithRefresh(): Promise<Record<string, any>>;

package/dist/types/Services/User/UserTranslation.d.ts

@@ -0,0 +1,3 @@
+import { Concept } from './../../DataStructures/Concept';
+export declare function GetUserGhostId(userId: number, ghostId: number, sessionId?: number): Promise<Concept>;
+export declare function AddGhostConcept(concept: Concept, userId: number, sessionId?: number): Promise<void>;

package/dist/types/Services/View/ViewInternalData.d.ts

@@ -0,0 +1 @@
+export declare function ViewInternalData(ids: number[]): Promise<any[]>;

package/dist/types/Services/assets/GetImageService.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param url this is the url of the image that you have. This image will be cached in the cache server
+ * @param format this is the format it can be either normal , small, by default it is normal
+ * @returns
+ */
+export declare function GetFreeschemaImage(url: string, format?: string): Promise<any>;
+/**
+ *
+ * @param url this is the url of the image that you have. This image will be cached in the cache server
+ * @param format this is the format it can be either normal , small, by default it is normal
+ * @returns
+ */
+export declare function GetFreeschemaImageUrl(url: string, format?: string): string;

package/dist/types/Services/automated/automated-concept-connection.d.ts

@@ -0,0 +1,7 @@
+import { Concept, InnerActions } from "../../app";
+export declare function CreateData(json: any, ofConcept?: Concept | null, typeConcept?: string, actions?: InnerActions): Promise<any>;
+export declare function removePrefix(key: string): string;
+export declare function addPrefix(key: string): string;
+export declare function addArrayPrefix(key: string): string;
+export declare function removeArrayPrefix(key: string): string;
+export declare function createTypeString(typeConceptString: string, key: any): string;

package/dist/types/Services/cacheService.d.ts

@@ -0,0 +1 @@
+export declare function requestNextCacheServer(requestData: any, url: string): Promise<Response>;

package/dist/types/Validator/constant.d.ts

@@ -0,0 +1,3 @@
+export declare const DATA_TYPES_RULES: {
+    [key: string]: RegExp;
+};

package/dist/types/Validator/interface.d.ts

@@ -0,0 +1,19 @@
+export interface FormErrors {
+    [key: string]: {} | undefined;
+}
+export interface FormFieldData {
+    name: string | null;
+    value: string | null;
+    type?: string | null;
+    dataType?: string | null;
+    pattern?: string | null;
+    conceptType?: string | null;
+    maxLength?: number | null;
+    minLength?: number | null;
+    minValue?: number | null;
+    maxValue?: number | null;
+    accept?: string | null;
+    file?: File | null;
+    required?: boolean;
+    isUnique?: boolean;
+}

package/dist/types/Validator/utils.d.ts

@@ -0,0 +1,7 @@
+import { FormFieldData } from "./interface";
+/**
+ * Utility function to get input field data and attributes
+ * @param fieldName - The Name of the form field.
+ * @returns - An object containing the field's value and constraints (type, maxLength, etc.).
+ */
+export declare const createFormFieldData: (fieldName: string) => FormFieldData;

package/dist/types/Validator/validator.d.ts

@@ -0,0 +1,37 @@
+import { FormErrors, FormFieldData } from "./interface";
+export declare class Validator {
+    /**
+     * Checks if a concept with the given type and value is unique.
+     * @param type concept type where to check
+     * @param value value to check
+     * @returns boolean indicating uniqueness
+     */
+    checkUniqueness(type: string, value: string): Promise<boolean>;
+    /**
+     * Validates a single form field based on its constraints and uniqueness.
+     * @param options - An object containing field properties including name, value, type, and validation constraints.
+     * @returns An object containing validation errors if validation fails.
+     */
+    validateField(options: FormFieldData): Promise<{
+        [fieldName: string]: string;
+    }>;
+    /**
+     * Validates all form fields by iterating over the provided form data.
+     * It checks each field's value, data type, and constraints, collecting errors where necessary.
+     *
+     * @param formData - An object representing the form data, where each key is a field name
+     *                   and each value is an object containing the `value`, `dataType`, and constraints (e.g., `maxLength`, `minLength`).
+     *
+     * @returns An object containing validation errors for fields that failed validation.
+     *          If no errors exist, the object will be empty.
+     */
+    validateForm(formData: {
+        [key: string]: FormFieldData;
+    }): Promise<FormErrors>;
+    /**
+     * Take field element attributes
+     * @param options  Object conist of attributes
+     * @returns Object with status and details
+     */
+    validate(options: FormFieldData): any;
+}

package/dist/types/Widgets/BaseObserver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Observable base class implementing the Observer pattern for reactive widgets.
+ *
+ * Provides data change notification system allowing subscribers to react to state updates.
+ */
+export declare class BaseObserver {
+    /** Widget data that can be observed for changes */
+    data: any;
+    /** Flag to enable development mode features */
+    inDevelopment: boolean;
+    /** Array of callback functions subscribed to data changes */
+    subscribers: any;
+    /**
+    * Notifies all subscribers when data changes.
+    *
+    * @param passedData - Optional data to pass to subscribers. Uses this.data if not provided.
+    */
+    notify(passedData?: any): void;
+    /**
+     * Registers a callback function to be invoked on data changes.
+     *
+     * @param callback - Function to execute when data changes
+     */
+    dataChange(callback: any): void;
+}

package/dist/types/Widgets/BaseWidget.d.ts

@@ -0,0 +1,37 @@
+import { BaseObserver } from "./BaseObserver";
+/**
+ * Base widget class providing core DOM element management and identification.
+ *
+ * Extends BaseObserver to provide reactive data capabilities along with fundamental
+ * widget element operations and unique identification.
+ */
+export declare class BaseWidget extends BaseObserver {
+    /** The mounted DOM element wrapper for this widget */
+    element: HTMLElement | null;
+    /** Unique numeric identifier for this widget instance */
+    elementIdentifier: number;
+    /** Flag indicating whether the widget has been mounted to the DOM */
+    widgetMounted: boolean;
+    /**
+     * Gets the root component element of this widget.
+     *
+     * @returns The widget's root HTML element or null if not mounted
+     */
+    getComponent(): HTMLElement | null;
+    /**
+     * Finds an element by ID within this widget's scope.
+     *
+     * @param identifier - The element ID to search for (without '#' prefix)
+     * @returns The found HTML element or null if not found
+     */
+    getElementById(identifier: string): HTMLElement | null;
+    /**
+     * Generates a unique identifier for this widget's wrapper element.
+     *
+     * Creates a random number to uniquely identify the widget and its children
+     * from other widgets in the DOM.
+     *
+     * @returns The generated identifier as a string
+     */
+    createWidgetWrapperIdentifier(): string;
+}

package/dist/types/Widgets/BuilderSpeceficFunctions.d.ts

@@ -0,0 +1,11 @@
+import { BuilderStatefulWidget } from "./BuilderStatefulWidget";
+/**
+ * Opens the type editor interface for a widget in development mode.
+ *
+ * Creates an input field allowing developers to change the widget type
+ * dynamically. Updates the widget when type value changes.
+ *
+ * @param event - The click event that triggered the editor
+ * @param that - The BuilderStatefulWidget instance to edit
+ */
+export declare function TypeEditor(event: any, that: BuilderStatefulWidget): void;