mftsccs-browser 2.2.20-beta → 2.2.22-beta

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

@@ -1,50 +1,187 @@
 import { BuilderStatefulWidget, StatefulWidget, WidgetTree } from "../app";
+/**
+ * Renders a complete page with its widgets and properties.
+ *
+ * Fetches page data, applies page-level properties (meta tags, styles), and renders
+ * the page body widget. Adds fspage class for styling.
+ *
+ * @param pageId - The page concept ID to render
+ * @param attachNode - DOM element to attach the page to
+ * @param props - Optional properties to pass to the page widget
+ * @param showDocumentation - Whether to show documentation button
+ */
 export declare function renderPage(pageId: number, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<void>;
+/**
+ * Imports the latest version of a widget into cache for later rendering.
+ *
+ * Fetches widget data, builds widget tree, and stores in DataCache.
+ * Used for pre-loading widgets before rendering.
+ *
+ * @param widgetId - The widget origin ID to import
+ * @param attachNode - Optional DOM element (for future use)
+ * @param props - Optional properties to pass to the widget
+ * @param showDocumentation - Whether to show documentation button
+ * @returns Promise resolving to the widget tree
+ */
 export declare function importLatestWidget(widgetId: number, attachNode?: HTMLElement, props?: any, showDocumentation?: boolean): Promise<WidgetTree | undefined>;
+/**
+* Imports the latest version of a widget into cache for later rendering.
+*
+* Fetches widget data, builds widget tree, and stores in DataCache.
+* Used for pre-loading widgets before rendering.
+*
+* @param widgetId - The widget origin ID to import
+* @param attachNode - Optional DOM element (for future use)
+* @param props - Optional properties to pass to the widget
+* @param showDocumentation - Whether to show documentation button
+* @returns Promise resolving to the widget tree
+*/
+export declare function importRecentWidget(widgetId: number, attachNode?: HTMLElement, props?: any, showDocumentation?: boolean): Promise<WidgetTree | undefined>;
+/**
+ * Renders a previously imported widget from cache.
+ *
+ * Retrieves widget tree from DataCache and renders it to the DOM.
+ * Must call importLatestWidget() first to populate cache.
+ *
+ * @param widgetId - The widget origin ID to render
+ * @param attachNode - DOM element to attach the widget to
+ * @param props - Optional properties to pass to the widget
+ * @param showDocumentation - Whether to show documentation button
+ * @returns Promise resolving to the rendered widget instance
+ */
 export declare function renderImportedWidget(widgetId: number, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<BuilderStatefulWidget | undefined>;
+/**
+ * Renders the latest published version of a widget.
+ *
+ * Fetches and renders the most recent version of a widget by origin ID.
+ * Automatically handles "use latest" flag for child widgets.
+ *
+ * @param widgetId - The widget origin ID to render
+ * @param attachNode - DOM element to attach the widget to
+ * @param props - Optional properties to pass to the widget
+ * @param showDocumentation - Whether to show documentation button
+ */
 export declare function renderLatestWidget(widgetId: number, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<BuilderStatefulWidget | undefined>;
+/**
+ * Renders a specific widget by ID.
+ *
+ * Fetches widget data and renders the exact version specified (not latest).
+ *
+ * @param widgetId - The specific widget ID to render
+ * @param attachNode - DOM element to attach the widget to
+ * @param props - Optional properties to pass to the widget
+ * @param showDocumentation - Whether to show documentation button
+ * @returns Promise resolving to the rendered widget instance
+ */
 export declare function renderWidget(widgetId: number, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<BuilderStatefulWidget | undefined>;
+/**
+ * Materializes a widget tree into DOM elements with styles and scripts.
+ *
+ * Core rendering logic that converts widget data into live DOM, applies styles,
+ * initializes libraries, and attaches documentation if enabled.
+ *
+ * @param widgetId - The widget ID being materialized
+ * @param bulkWidget - Bulk widget data from backend
+ * @param attachNode - DOM element to attach the widget to
+ * @param props - Optional properties to pass to the widget
+ * @param showDocumentation - Whether to show documentation button (default: true)
+ * @returns Promise resolving to the rendered widget instance
+ */
 export declare function materializeWidget(widgetId: number, bulkWidget: any, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<BuilderStatefulWidget | undefined>;
+/**
+ * Fetches and builds a complete widget tree from a widget ID.
+ *
+ * @param widgetId - The widget ID to fetch
+ * @param visitedWidgets - Array to track visited widgets (prevents cycles)
+ * @param token - Optional authentication token
+ * @returns Promise resolving to the widget tree
+ */
 export declare function getWidgetFromId(widgetId: number, visitedWidgets?: number[], token?: string): Promise<WidgetTree>;
 /**
- * This function builds a widget tree. This tree is built fully along with its children
- * This tree can then be used to build the whole dom for the widget.
- * This has recursive property so that the recursion can be used to build this tree.
- * @param widgetId the id of the widget
- * @returns WidgetTree.
+ * Builds a complete widget tree from bulk widget data.
+ *
+ * Recursively processes widget hierarchy including children, custom functions,
+ * libraries, and lifecycle hooks to create a full WidgetTree structure.
+ *
+ * @param widgetId - The widget ID to build tree for
+ * @param visitedWidgets - Array tracking visited widgets to prevent cycles
+ * @param bulkWidget - Bulk widget data from backend
+ * @param token - Optional authentication token
+ * @returns Promise resolving to the complete widget tree
  */
 export declare function getWidgetBulkFromId(widgetId: number, visitedWidgets: number[] | undefined, bulkWidget: any, token?: string): Promise<WidgetTree>;
 /**
+ * Converts a widget tree structure into live widget instances and mounts to DOM.
+ *
+ * Recursively instantiates widgets from tree data, sets up parent-child relationships,
+ * applies styles, and mounts to the specified parent element.
  *
- * @param tree Widget tree from getWidgetFromId(widgetId);
- * @param parentElement this is the dom element on which we want to add our widget
- * @returns the widgetree with widgets attached inside of it.
- * Also this will add the tree to the dom.
+ * @param tree - The widget tree to convert
+ * @param parentElement - DOM element to mount the widget to
+ * @param isMain - Whether this is the main/root widget
+ * @param props - Optional properties to pass to the widget
+ * @param state - Optional state data to pass to the widget
+ * @param parentWidget - Parent widget instance for context
+ * @returns Promise resolving to the instantiated widget
  */
 export declare function convertWidgetTreeToWidget(tree: WidgetTree, parentElement: HTMLElement, isMain?: boolean, props?: any, state?: any, parentWidget?: StatefulWidget | null): Promise<BuilderStatefulWidget>;
+/**
+ * Creates a shallow copy of an object, excluding arrays and nested objects.
+ *
+ * @param input - Object to create shallow copy from
+ * @returns Shallow copy with only primitive and null values
+ */
 export declare function makeShallow(input: any): any;
 /**
-*
-* @param tree Widget tree from getWidgetFromId(widgetId);
-* @param parentElement this is the dom element on which we want to add our widget
-* @returns the widgetree with widgets attached inside of it.
-* Also this will add the tree to the dom.
-*/
+ * Converts widget tree to widget instances with development mode wrapper support.
+ *
+ * Similar to convertWidgetTreeToWidget but includes development mode features
+ * like visual editing and type selection.
+ *
+ * @param tree - The widget tree to convert
+ * @param parentElement - DOM element to mount the widget to
+ * @param isMain - Whether this is the main/root widget
+ * @param state - Optional state data to pass to the widget
+ * @param isInDevelopment - Enable development mode features
+ * @param parentWidget - Parent widget instance for context
+ * @returns Promise resolving to the instantiated widget
+ */
 export declare function convertWidgetTreeToWidgetWithWrapper(tree: WidgetTree, parentElement: HTMLElement, isMain?: boolean, state?: object, isInDevelopment?: boolean, parentWidget?: StatefulWidget | null): Promise<BuilderStatefulWidget>;
+/**
+ * Recursively unwraps all matching container elements within a parent.
+ *
+ * @param parentElement - Parent element to search within
+ * @param selector - CSS selector for containers to unwrap
+ */
 export declare function unwrapContainers(parentElement: HTMLElement, selector: string): Promise<void>;
 /**
- * Opens documentation modal
- * @param widgetId
+ * Opens the documentation preview modal for a widget.
+ *
+ * Fetches and displays widget documentation including API specs, code examples,
+ * images, videos, and links.
+ *
+ * @param widgetId - The widget ID to show documentation for
  */
 export declare function openDocumentationPreviewModal(widgetId: number): Promise<void>;
+/**
+ * Renders widget documentation content into the documentation view.
+ *
+ * Formats and displays documentation data including text, API details,
+ * code examples, and media attachments.
+ *
+ * @param widgetDocumentData - Documentation data to display
+ * @param widgetId - The widget ID being documented
+ */
 export declare function showWidgetDocumentation(widgetDocumentData: any, widgetId: number): Promise<void>;
 /**
- * Opens modal
- * @param modalId
+ * Opens a modal dialog by ID.
+ *
+ * @param modalId - The ID of the modal element to open
  */
 export declare function openModal(modalId: string): Promise<void>;
 /**
- * Closes modal
- * @param modalId
+ * Closes a modal dialog by ID and resets its form if present.
+ *
+ * @param modalId - The ID of the modal element to close
  */
 export declare function closeModal(modalId: string): Promise<void>;

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

@@ -1,102 +1,167 @@
 import { BaseWidget } from "./BaseWidget";
 /**
- * Implementation of a widget system. If you need to create a widget that is compatible with the concept connection
- * system them extend this class and populate the functions such as getHtml() and widgetDidMount()
+ * Stateful widget with lifecycle management and hierarchical composition.
+ *
+ * Provides a React-like component system with state management, lifecycle hooks,
+ * and parent-child widget relationships. Extend this class to create custom widgets
+ * compatible with the concept connection system.
  */
 export declare class StatefulWidget extends BaseWidget {
+    /** Optional parameters passed to the widget */
     params: any;
+    /** HTML template string for the widget */
     html: string;
+    /** CSS styles for the widget */
     css: string;
+    /** JavaScript code for the widget */
     js: string;
+    /** Current widget state object */
     state: {
         [key: string]: any;
     };
+    /** Previous widget state for change detection */
     previousState: {
         [key: string]: any;
     };
-    /**
-     * These are the child widgets that need to be added to  this widget
-     */
+    /** Array of child widget instances */
     childWidgets: any;
+    /** Array of DOM elements hosting child widgets */
     childWidgetElement: any;
+    /** Reference to the parent widget instance */
     parentWidget: any;
-    /**
-     * store widget state datas to pass through child widgets
-     */
+    /** Shared state data passed to child widgets */
     widgetState: {
         [key: string]: any;
     };
+    /** ID of the parent DOM element containing this widget */
+    parentElement: string;
     /**
-     * This is the id of the parentElement of this widget.
+     * Finds the first element matching a CSS selector within this widget.
+     *
+     * @param selector - CSS selector string
+     * @returns The first matching element or null
      */
-    parentElement: string;
     querySelector(selector: string): Element | null;
+    /**
+     * Finds all elements matching a CSS selector within this widget.
+     *
+     * @param selector - CSS selector string
+     * @returns NodeList of matching elements or null
+     */
     querySelectorAll(selector: string): NodeListOf<Element> | null;
+    /**
+     * Gets the root DOM element of this widget.
+     *
+     * @returns The widget's root HTML element
+     */
     getElement(): HTMLElement | null;
+    /**
+     * Sets the browser document title.
+     *
+     * @param title - The new document title
+     */
     setTitle(title: string): void;
     /**
+     * Gets the HTML template for this widget.
      *
-     * @returns the html string that needs to be mounted to the DOM.
+     * @returns HTML string to be rendered
      */
     getHtml(): string;
     /**
-     * This will help us update the data of the child widget. This will also call another function inside of the child widget
-     * called udpateWidget which the user can call after some data is udpated.
-     * @param value
-     * @param widget
+     * Updates a child widget's data and triggers re-render.
+     *
+     * @param value - New data to pass to the child widget
+     * @param widget - The child widget instance to update
      */
     UpdateChildData(value: any, widget: StatefulWidget): void;
     /**
-     * This is called after the data has been udpated by some other component.
+     * Lifecycle hook called after widget data is updated.
+     * Override this method to handle post-update logic.
      */
     update(): void;
     /**
+     * Updates the entire widget state and triggers re-render if changed.
      *
-     * @param newState
+     * @param newState - New state data to replace current state
      */
     setState(newState: any): void;
+    /**
+     * Updates specific state properties and triggers re-render if changed.
+     *
+     * @param newProperty - Object containing properties to update
+     */
     setStateProperty(newProperty: Object): void;
+    /**
+     * Checks if the widget state has changed since last update.
+     *
+     * @returns True if state changed, false otherwise
+     */
     hasStateChanged(): boolean;
+    /**
+     * Compares two state objects for shallow equality.
+     *
+     * @param obj1 - First state object
+     * @param obj2 - Second state object
+     * @returns True if objects are equal, false otherwise
+     */
     private isPropertyEqual;
     /**
-     * If any child widgets are registered in the widget. Then without any other changes to the contents and state
-     * this loadChildWidgets will be called which will help the child widgets be rendered to their respective positions.
+     * Mounts all registered child widgets to their designated parent elements.
      */
     loadChildWidgets(): void;
     /**
-     * This is the main function that adds the html of the component to the element.
-     * The element is the mounted widget
+     * Re-renders the widget by updating the DOM with current HTML template.
+     * Also triggers child widget loading and after_render hook.
      */
     render(): void;
+    /**
+     * Finds all elements with a specific class name within this widget.
+     *
+     * @param identifier - Class name to search for (without '.' prefix)
+     * @returns NodeList of matching elements
+     */
     getElementByClassName(identifier: string): never[] | NodeListOf<Element>;
     /**
-     * This is the function that needs to be called.
+     * Lifecycle hook for mounting child widgets.
+     * Override this method to define custom child mounting logic.
      */
     mount_child(): void;
     /**
+     * Mounts the widget to a parent DOM element and initializes lifecycle.
+     *
+     * Creates a wrapper div, assigns unique ID, renders HTML, and executes
+     * lifecycle hooks in sequence.
      *
-     * @param parent This is the function that creates a new div and then mounts the html element to the parent.
+     * @param parent - The parent HTML element to mount this widget into
      */
     mount(parent: HTMLElement): Promise<void>;
     /**
-     * This function will be called after the component mounts.
+     * Lifecycle hook called before rendering.
+     * Override for initialization logic. Default implementation calls render().
      */
     before_render(): void;
     /**
-     * This is called after the render function has been called. So this is used for the user functions to be added
-     * for the widget and its html element. User can add any logic here.
+     * Lifecycle hook called after rendering.
+     * Override to add event listeners or post-render logic.
      */
     after_render(): void;
     /**
-     * render child widgets
+     * Recursively renders all child widgets in the hierarchy.
      */
     renderChildWidgets(): void;
     /**
-     * save widget state data as key and value pair.
+     * Sets shared state data and propagates to all child widgets recursively.
+     *
+     * @param key - State property key
+     * @param value - State value to set
      */
     setWidgetState(key: string, value: any): void;
     /**
-     * get the saved widget state from stateful widget
+     * Retrieves shared state data by key.
+     *
+     * @param key - State property key to retrieve
+     * @param defaultValue - Default value if key doesn't exist
+     * @returns The state value or default value
      */
     getWidgetState(key: string, defaultValue: any): object;
 }

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

@@ -1,4 +1,45 @@
+/**
+ * Fetches and builds widget data from the backend by widget ID.
+ *
+ * Retrieves complete widget structure including concepts, connections, and metadata.
+ * Uses caching to prevent duplicate requests for the same widget.
+ *
+ * @param id - The widget ID to fetch
+ * @returns Promise resolving to formatted widget data
+ */
 export declare function BuildWidgetFromId(id: number): Promise<any>;
+/**
+ * Builds widget data from local cache instead of making API request.
+ *
+ * @param id - The widget ID to fetch from cache
+ * @returns Promise resolving to widget data object with mainId
+ */
 export declare function BuildWidgetFromCache(id: number): Promise<any>;
+/**
+ * Fetches the latest published version of a widget by origin ID.
+ *
+ * Retrieves the most recent version of a widget, useful for always displaying
+ * updated content. Uses separate cache from standard widget requests.
+ *
+ * @param id - The origin widget ID to fetch latest version for
+ * @returns Promise resolving to object with widget data and mainId
+ */
 export declare function BuildWidgetFromIdForLatest(id: number): Promise<any>;
+/**
+ * Fetches the recent published version of a widget by origin ID.
+ *
+ * Retrieves the most recent version of a widget, useful for always displaying
+ * updated content. Uses separate cache from standard widget requests.
+ *
+ * @param id - The origin widget ID to fetch latest version for
+ * @returns Promise resolving to object with widget data and mainId
+ */
+export declare function BuildWidgetFromIdForRecent(id: number): Promise<any>;
+/**
+ * Finds and returns a specific widget from bulk widget data by ID.
+ *
+ * @param data - Array of widget data objects
+ * @param id - The widget ID to find
+ * @returns The matching widget object or undefined
+ */
 export declare function GetWidgetForTree(data: any, id: number): any;

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

@@ -1,29 +1,60 @@
 import { TAssistant, TCustomFunction, TMainLibrary } from "../DataStructures/TypeLibrary";
 import { BuilderStatefulWidget } from "./BuilderStatefulWidget";
+/**
+ * Hierarchical widget tree structure for nested widget composition.
+ *
+ * Represents a widget and its complete metadata including HTML, styles, scripts,
+ * lifecycle hooks, and child widgets. Used for building complex widget hierarchies.
+ */
 export declare class WidgetTree {
+    /** Unique widget identifier */
     id: number;
+    /** Widget display name */
     name: string;
+    /** HTML template string */
     html: string;
+    /** CSS styles string */
     css: string;
+    /** JavaScript code string */
     js: string;
+    /** External CSS and JS library dependencies */
     library: TMainLibrary;
+    /** AI assistant configuration for the widget */
     assistant: TAssistant;
+    /** Creation/update timestamp */
     timestamp: string;
+    /** Widget ID reference */
     widgetId: number;
+    /** Widget type identifier (e.g., "the_element_name") */
     type: string;
+    /** Clean/sanitized version of the widget */
     clean: string;
+    /** Code to execute after widget renders */
     after_render: string;
+    /** Code to execute before widget renders */
     before_render: string;
+    /** Array of custom function definitions */
     custom_functions: TCustomFunction[];
+    /** Code to execute on widget update */
     update: string;
+    /** Origin widget ID for versioning */
     origin: number;
+    /** Version number of this widget */
     version: number;
+    /** Code to execute when mounting child widgets */
     mount_child: string;
+    /** Array of child widget trees */
     children: WidgetTree[];
+    /** ID of the wrapper element for this widget */
     wrapper: string;
+    /** The instantiated widget object */
     widget: BuilderStatefulWidget;
+    /** Child widget ID reference */
     sChildId?: number;
+    /** Whether the widget is published */
     isPublished?: boolean;
+    /** Whether to use the latest version of this widget */
     useLatest?: boolean;
+    /** Widget dependency code string */
     dependency: string;
 }

package/dist/types/Widgets/mainView.class.d.ts

@@ -1,6 +1,27 @@
+/**
+ * Base view class for page-level components.
+ *
+ * Provides basic page functionality including title management and HTML generation.
+ */
 export default class {
+    /** Parameters passed to the view */
     params: any;
+    /**
+     * Creates a new view instance.
+     *
+     * @param params - Configuration parameters for the view
+     */
     constructor(params: any);
+    /**
+     * Sets the browser document title.
+     *
+     * @param title - The new document title
+     */
     setTitle(title: string): void;
+    /**
+     * Generates the HTML content for this view.
+     *
+     * @returns HTML string for the view
+     */
     getHtml(): Promise<string>;
 }

package/dist/types/WrapperFunctions/DepenedencyObserver.d.ts

@@ -1,73 +1,94 @@
 /**
- * This is the class that helps us observe anything that the function is doing
- * This wrapper will allow all the concepts and connections to be tracked inside of the called function
- * This function helps us manage state using the concept connection system.
+ * Base observable class that tracks concepts and connections for reactive state management.
+ * Implements the observer pattern to notify subscribers when tracked data changes.
  */
 export declare class DependencyObserver {
+    /** List of subscriber callbacks */
     subscribers: any[];
+    /** Primary concept ID being observed */
     mainConcept: number;
+    /** List of composition IDs */
     compositionIds: number[];
+    /** List of concept IDs */
     conceptIds: number[];
+    /** List of internal connection IDs */
     internalConnections: number[];
+    /** List of reverse connection IDs */
     reverse: number[];
+    /** List of linker connection IDs */
     linkers: number[];
+    /** List of newly added IDs */
     newIds: number[];
+    /** List of dependency IDs */
     dependency: number[];
+    /** Whether initial data has been loaded */
     isDataLoaded: boolean;
+    /** Whether an update is currently in progress */
     isUpdating: boolean;
+    /** The observable data to be returned */
     data: any;
+    /** Whether data has been fetched */
     fetched: boolean;
+    /** Output format (NORMAL, DATAID, JUSTDATA, etc.) */
     format: number;
+    /** Map of concept IDs to their event handlers */
     eventHandlers: {
         [key: number]: (event: Event) => void;
     };
     /**
-     * This function will be called when there is a need to listen to a certain type of concept that will update
-     *  the ui.
-     * @param id this is the type id which needs to be tracked
+     * Listens to changes for a specific concept type and updates subscribers when new concepts of that type are created.
+     * @param id - The type concept ID to track
      */
     listenToEventType(id: number): void;
     /**
-     * This is the of the concept id that needs to be listened . If this is called. All the connections that are
-     * created with of the concepts id with this passed id then the event is fired.
-     *
-     * @param id Of the concept id that needs to be listened.
+     * Listens to connection changes for a specific concept and updates subscribers when connections are modified.
+     * @param id - The concept ID to track
      */
     listenToEvent(id: number): void;
+    /**
+     * Removes an event listener for a specific concept ID.
+     * @param id - The concept ID to stop tracking
+     */
     removeListenToEvent(id: number): void;
     /**
- * This is the of the concept id that needs to be listened . If this is called. All the connections that are
- * created with of the concepts id with this passed id then the event is fired.
- *
- * @param id Of the concept id that needs to be listened.
- */
+     * Listens to connection changes filtered by connection type for a specific concept.
+     * @param id - The concept ID to track
+     * @param connectionType - The connection type ID to filter by
+     */
     listenToEventConnectionType(id: number, connectionType: number): void;
     /**
-     * This function will bind the actual data to the widget or the function.
+     * Binds and refreshes the observable data. Override in subclasses to implement specific data fetching logic.
+     * @returns The bound data
      */
     bind(): Promise<void>;
+    /**
+     * Executes the observable without subscribing. Override in subclasses for non-reactive data fetching.
+     * @returns The executed data
+     */
     run(): Promise<void>;
+    /**
+     * Forces a data refresh and notifies all subscribers.
+     */
     update(): Promise<void>;
     /**
-     *
-     * @param callback the function that needs to be called with the data.
-     * @returns returns the callback with this data as the state.
+     * Subscribes a callback to receive data updates whenever tracked concepts/connections change.
+     * @param callback - Function to call with (data, observer) when updates occur
+     * @returns Result of calling the callback with current data
      */
     subscribe(callback: any): Promise<any>;
     /**
-*
-*
-* @returns data
-*/
+     * Executes the observable once without subscribing to updates.
+     * @returns The executed data
+     */
     execute(): Promise<void>;
     /**
-     *
-     * @param callback function that you need to remove from the subscribers list.
-     * @returns
+     * Removes a callback from the subscriber list.
+     * @param callback - The callback function to remove
+     * @returns Number of remaining subscribers
      */
     unsubscribe(callback: any): number;
     /**
-     * This function will call all the subscribers that are registered in this wrapper.
+     * Notifies all subscribers with the current data.
      */
     notify(): void;
 }