@orangelogic/design-system 2.19.0-ci.5

package/library/packages/organisms/src/file-on-demand/file-on-demand.utils.d.ts

@@ -0,0 +1,52 @@
+import { Asset, FolderOption } from '../../../types/src/file-on-demand';
+
+export declare const partitionAssets: (assets: Asset[]) => [Asset[], Asset[]];
+export declare const fetchFolders: ({ excludes, folderId, folderPath, folderPathsSet, limit, searchText, seeThru, siteUrl, start, token, }: {
+    excludes?: string[];
+    folderId: string;
+    folderPath?: string[];
+    folderPathsSet?: Set<string>;
+    limit?: number;
+    searchText?: string;
+    seeThru?: boolean;
+    siteUrl: string;
+    start?: number;
+    token: string;
+}) => Promise<{
+    data: FolderOption[];
+    totalCount: number;
+}>;
+export declare function getValueByKeyCaseInsensitive(obj: {
+    [key: string]: string;
+}, key: string): string | undefined;
+export declare const extractRootData: (rootID: string) => {
+    id: string;
+    path: string;
+};
+export declare const getRootIDString: ({ id, path }: {
+    id: string;
+    path: string;
+}) => string;
+export declare const getFileExtension: (fileName: string) => string;
+export declare const extractVersion: (input: string) => string;
+export declare const getPath: (path: string[], fullPath: string) => string;
+/**
+ * Normalize the asset path by removing extra spaces before and after slashes
+ * @param str - The asset path to normalize
+ * @returns The normalized asset path
+ */
+export declare const normalizeAssetPath: (str: string) => string;
+/**
+ * Creates a set containing only the title by splitting the path string
+ * @param folderPathsSet - Set of folder paths
+ * @returns Set containing only the title
+ */
+export declare const getTitleSet: (folderPathsSet: Set<string>) => Set<string>;
+/**
+ * Reduces the full path to the direct child of the base path.
+ * E.g: 'Root/folder1/folder2/folder3/folder4' with base 'Root/folder1/folder2' -> 'Root/folder1/folder2/folder3'
+ * @param full - The full path
+ * @param base - The base path
+ * @returns The reduced path
+ */
+export declare const reducePathToDirectChild: (full: string, base: string) => string;

package/library/packages/organisms/src/index.d.ts

@@ -0,0 +1,15 @@
+export { default as CxAssetLinkFormat } from './asset-link-format/asset-link-format';
+export { default as CxBentoGrid } from './bento-grid/bento-grid';
+export { default as CxCarousel } from './carousel/carousel';
+export { default as CxChatbot } from './chatbot/chatbot';
+export { default as CxClusterManagement } from './cluster-management/cluster-management';
+export { default as CxColorSwatchGroup } from './color-swatch-group/color-swatch-group';
+export { default as CxComment } from './comment/comment';
+export { default as CxContentBuilder } from './content-builder/content-builder';
+export { default as CxDownloader } from './downloader/downloader';
+export { default as CxFileOnDemand } from './file-on-demand/file-on-demand';
+export { default as CxMultiSelect } from './multi-select/multi-select';
+export { default as CxTemplateSwitcher } from './template-switcher/template-switcher';
+export { default as CxTextToSpeech } from './text-to-speech/text-to-speech';
+export { default as CxVideoChaptersManager } from './video-chapters-manager/video-chapters-manager';
+export { default as CxVideoEditor } from './video-editor/video-editor';

package/library/packages/organisms/src/library-index.d.ts

@@ -0,0 +1,3 @@
+export { default as CxAssetLinkFormat } from './asset-link-format/asset-link-format';
+export { default as CxColorSwatchGroup } from './color-swatch-group/color-swatch-group';
+export { default as CxFileOnDemand } from './file-on-demand/file-on-demand';

package/library/packages/organisms/src/multi-select/components/board/board.d.ts

@@ -0,0 +1,116 @@
+import { default as CxIcon } from '../../../../../atoms/src/components/icon/icon.ts';
+import { default as CxIconButton } from '../../../../../atoms/src/components/icon-button/icon-button.ts';
+import { default as CxInput } from '../../../../../atoms/src/components/input/input.ts';
+import { default as CxTooltip } from '../../../../../atoms/src/components/tooltip/tooltip.ts';
+import { default as CortexElement } from '../../../../../base/src/cortex-element.ts';
+import { BoardItem } from '../../../../../types/src/board';
+import { default as Sortable } from 'sortablejs';
+import { default as CxBoardListItem } from '../board-list-item/board-list-item';
+
+export type CxBoardChangeEvent = CustomEvent<Record<PropertyKey, unknown>>;
+export type CxBoardSelectedChangeEvent = CustomEvent<Record<PropertyKey, unknown>>;
+export type CxBoardItemAddedEvent = CustomEvent<Record<PropertyKey, unknown>>;
+export type CxBoardItemRemovedEvent = CustomEvent<Record<PropertyKey, unknown>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-board-change': CxBoardChangeEvent;
+        'cx-board-item-added': CxBoardItemAddedEvent;
+        'cx-board-item-removed': CxBoardItemRemovedEvent;
+        'cx-board-selected-change': CxBoardSelectedChangeEvent;
+    }
+}
+/**
+ * @summary Board is a list of items that can be reordered by dragging and dropping them.
+ *
+ * @event {{ items: string[] }} cx-sort-change - Emitted when the list items changes.
+ */
+export default class CxBoard extends CortexElement {
+    static readonly styles: import('lit').CSSResult[];
+    static readonly dependencies: {
+        'cx-board-list-item': typeof CxBoardListItem;
+        'cx-icon': typeof CxIcon;
+        'cx-icon-button': typeof CxIconButton;
+        'cx-input': typeof CxInput;
+        'cx-tooltip': typeof CxTooltip;
+    };
+    private readonly localize;
+    board: HTMLElement;
+    searchInput?: CxInput;
+    searchInputClear?: CxIconButton;
+    list: HTMLElement;
+    selectAllCheckBox: HTMLElement;
+    boardTitle: string;
+    name: string;
+    ignoreTypes: string[];
+    data: BoardItem[];
+    sort: boolean;
+    group: boolean;
+    configurable: boolean;
+    all: boolean;
+    allowSearch: boolean;
+    /**
+     * A boolean property that indicates whether the drag operation should be aborted.
+     * When set to `true`, the current drag action will be canceled,
+     * and the dragged items will be placed back to their original position.
+     */
+    abortDrag: boolean;
+    items: BoardItem[];
+    private _allItems;
+    get allItems(): BoardItem[];
+    private _filteredItems;
+    get filteredItems(): BoardItem[];
+    /** The selected items in the board. */
+    private _selectedItems;
+    private _selectedItemOrder;
+    get selectedItemAsArray(): string[];
+    get selectedItems(): Record<string, boolean>;
+    get selectedItemOrder(): Record<string, number>;
+    searchValue: string;
+    private sortable;
+    private _totalCount;
+    private _totalDisplayedCount;
+    private _indexMap;
+    get totalCount(): number;
+    get totalDisplayedCount(): number;
+    private isDragging;
+    private start;
+    private end;
+    private previous;
+    private lastSelectedItem;
+    get selectedCount(): number;
+    get isAllSelected(): boolean;
+    get isPartiallySelected(): boolean;
+    constructor();
+    private resetSelectedItems;
+    /** Handles the update of items in the board. */
+    private handleUpdateEvent;
+    private handleSelectedChange;
+    private handleItemConfigure;
+    private handleListScroll;
+    private handleSearchChange;
+    private handleSearchClear;
+    private concatGroupItems;
+    onSearchValueChanged(): void;
+    onItemsChanged(): void;
+    handleAdd(evt: Sortable.SortableEvent): void;
+    handleEnd(evt: Sortable.SortableEvent): Promise<void>;
+    handleRemove(evt: Sortable.SortableEvent): void;
+    handleDefaultSelect(item: CxBoardListItem): void;
+    handleShiftSelect(item: CxBoardListItem): void;
+    handleSelect(evt: MouseEvent): void;
+    handleStart(evt: Sortable.SortableEvent): void;
+    handleUpdate(evt: Sortable.SortableEvent): void;
+    deselectAll(force?: boolean): void;
+    selectAll(): void;
+    handleSelectAll(): void;
+    onAllChanged(): void;
+    private initSortable;
+    /** Initializes the sortable functionality for the list element. */
+    runFirstUpdated(): void;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-board': CxBoard;
+    }
+}

package/library/packages/organisms/src/multi-select/components/board/board.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/organisms/src/multi-select/components/board/board.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getHost: <T = Element>(el: HTMLElement) => T | null;
+export declare const isSafari: boolean;

package/library/packages/organisms/src/multi-select/components/board-list-item/board-list-item.d.ts

@@ -0,0 +1,49 @@
+import { default as CxIcon } from '../../../../../atoms/src/components/icon/icon.ts';
+import { default as CxIconButton } from '../../../../../atoms/src/components/icon-button/icon-button.ts';
+import { default as CxLineClamp } from '../../../../../atoms/src/components/line-clamp/line-clamp.ts';
+import { default as CxTooltip } from '../../../../../atoms/src/components/tooltip/tooltip.ts';
+import { default as CortexElement } from '../../../../../base/src/cortex-element.ts';
+import { TemplateResult } from 'lit';
+
+export type CxMultiSelectConfigureEvent = CustomEvent<Record<PropertyKey, string>>;
+export type CxBoardItemLabelClickEvent = CustomEvent<Record<PropertyKey, string>>;
+export type CxBoardItemCheckboxClickEvent = CustomEvent<Record<PropertyKey, string>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-board-item-checkbox-click': CxBoardItemCheckboxClickEvent;
+        'cx-board-item-label-click': CxBoardItemLabelClickEvent;
+        'cx-multi-select-configure': CxMultiSelectConfigureEvent;
+    }
+}
+export default class CxBoardListItem extends CortexElement {
+    static readonly styles: import('lit').CSSResult[];
+    static readonly dependencies: {
+        'cx-icon': typeof CxIcon;
+        'cx-icon-button': typeof CxIconButton;
+        'cx-line-clamp': typeof CxLineClamp;
+        'cx-tooltip': typeof CxTooltip;
+    };
+    configButton: CxIconButton;
+    textElement: HTMLElement;
+    tooltipElement: CxTooltip;
+    controlElement: HTMLElement;
+    text: string;
+    tooltip: string;
+    readonly: boolean;
+    placeholder: boolean;
+    selected: boolean;
+    configurable: boolean;
+    disabledTooltip: boolean;
+    isGroup: boolean;
+    private onConfigButtonClick;
+    private onTextMouseEnter;
+    private onTextMouseLeave;
+    handleDisabledTooltipChange(): void;
+    runFirstUpdated(): void;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-board-list-item': CxBoardListItem;
+    }
+}

package/library/packages/organisms/src/multi-select/components/board-list-item/board-list-item.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/organisms/src/multi-select/multi-select.d.ts

@@ -0,0 +1,85 @@
+import { default as CxIconButton } from '../../../atoms/src/components/icon-button/icon-button.ts';
+import { default as CxTooltip } from '../../../atoms/src/components/tooltip/tooltip.ts';
+import { default as CortexElement } from '../../../base/src/cortex-element.ts';
+import { ColumnData } from '../../../types/src/multi-select';
+import { TemplateResult } from 'lit';
+import { default as CxBoard } from './components/board/board';
+
+export type CxMultiSelectChangeEvent = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-multi-select-change': CxMultiSelectChangeEvent;
+    }
+}
+/**
+ * @summary Multi-select allows the user to select multiple items from a list. The items can be moved between two columns. The user can move items between the columns by dragging and dropping them.
+ * @element cx-multi-select
+ *
+ * @event {{ items: BoardItem[], name: string }} cx-multi-select-change - Emitted when the list items change.
+ *
+ * @typedef BoardItem - {
+ *   group: string;
+ *   id: string;
+ *   index?: string;
+ *   text: string;
+ *   tooltip: string;
+ * }
+ *
+ * @typedef ColumnData - {
+ *   id: string;
+ *   items: BoardItem[];
+ *   sort?: boolean;
+ *   title: string;
+ * }
+ */
+export default class CxMultiSelect extends CortexElement {
+    static readonly styles: import('lit').CSSResult[];
+    static readonly dependencies: {
+        'cx-board': typeof CxBoard;
+        'cx-icon-button': typeof CxIconButton;
+        'cx-tooltip': typeof CxTooltip;
+    };
+    private readonly localize;
+    multiSelect: HTMLElement;
+    board1: CxBoard;
+    board2: CxBoard;
+    firstColumnData: ColumnData;
+    secondColumnData: ColumnData;
+    configurable: boolean;
+    ignoreTypes: string[];
+    addLimit: number | undefined;
+    private itemMap;
+    selectedItems: Record<string, string[]>;
+    private initialSecondColumnItems;
+    get firstColumnItemIds(): string[];
+    get secondColumnItemIds(): string[];
+    /**
+     * Validates the changes made to the items array based on the specified type of action ('add' or 'remove').
+     * If an add limit is set, it checks whether the new items exceed the allowed limit.
+     * If the limit is exceeded, a warning toast notification is displayed.
+     *
+     * @param items - The current array of items.
+     * @param oldItems - The previous array of items before the change.
+     * @param type - The type of action performed, either 'add' or 'remove'.
+     * @returns A boolean indicating whether the changes are valid (true) or not (false).
+     */
+    private isValidChanges;
+    private handleBoardChange;
+    private handleSelectedChange;
+    private handleMoveItems;
+    private handleMoveItemsRight;
+    private handleMoveItemsLeft;
+    onDataChange(): void;
+    runFirstUpdated(): void;
+    private moveSelectedItemRight;
+    private moveSelectedItemLeft;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-multi-select': CxMultiSelect;
+    }
+    interface GlobalEventHandlersEventMap {
+        'cx-multi-select-change': CxMultiSelectChangeEvent;
+    }
+}

package/library/packages/organisms/src/multi-select/multi-select.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/organisms/src/multi-select/multi-select.utils.d.ts

@@ -0,0 +1,3 @@
+import { BoardItem } from '../../../types/src/board';
+
+export declare const compareFunction: (a: BoardItem, b: BoardItem) => number;

package/library/packages/organisms/src/template-switcher/template-switcher-example.data.d.ts

@@ -0,0 +1,5 @@
+import { TemplateSwitcherProps } from '../../../types/src/template-switcher';
+import { MenuData } from '../../../types/src/view-and-sort';
+
+export declare const data: TemplateSwitcherProps;
+export declare const menu: MenuData;

package/library/packages/organisms/src/template-switcher/template-switcher.d.ts

@@ -0,0 +1,51 @@
+import { default as CortexElement } from '../../../base/src/cortex-element.ts';
+import { default as CxViewAndSort } from '../../../molecules/src/view-and-sort/view-and-sort.ts';
+import { ButtonVariant } from '../../../types/src/button';
+import { Settings, TemplateSwitcherProps } from '../../../types/src/template-switcher';
+import { MenuData } from '../../../types/src/view-and-sort';
+import { TemplateResult } from 'lit';
+
+/**
+ * @class CxTemplateSwitcher
+ * @extends CortexElement
+ * @summary Custom web component for switching templates in the Cortex application. The component manages various settings and menu configurations for different views, sort orders, and other options.
+ *
+ * @property {TemplateSwitcherProps} data - The data object containing initial settings and other configurations.
+ * @property {boolean | null} forcedSortOrder - Indicates if the sort order is forced.
+ * @property {string | null} forcedSortOrderReason - The reason for forcing the sort order.
+ * @property {MenuData} _menu - Internal state to store the menu data.
+ * @property {Settings} _settings - Internal state to store the settings.
+ * @property {boolean} _loading - Internal state to indicate if the component is loading.
+ *
+ * @event {{ item: MenuItem }} cx-select - Emitted when a menu item is selected.
+ */
+export default class CxTemplateSwitcher extends CortexElement {
+    static readonly dependencies: {
+        'cx-view-and-sort': typeof CxViewAndSort;
+    };
+    private readonly localize;
+    viewAndSort: CxViewAndSort;
+    data: TemplateSwitcherProps;
+    forcedSortOrder: boolean | null;
+    forcedSortOrderReason: string | null;
+    label: string;
+    triggerButtonVariant: ButtonVariant;
+    private _loading;
+    private _menu;
+    get menu(): MenuData;
+    private _settings;
+    get settings(): Settings;
+    private readonly iconMap;
+    handleDataChange(): void;
+    handleSettingsChange(): void;
+    handleAddCortexEvent(eventName: string, value: string, isSetting?: boolean): void;
+    handleItemSelect(event: CustomEvent): void;
+    runFirstUpdated(): void;
+    disconnectedCallback(): void;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-template-switcher': CxTemplateSwitcher;
+    }
+}

package/library/packages/organisms/src/template-switcher/template-switcher.icons.d.ts

@@ -0,0 +1,7 @@
+export declare const calendarIcon: import('lit').TemplateResult<1>;
+export declare const ganttIcon: import('lit').TemplateResult<1>;
+export declare const gridIcon: import('lit').TemplateResult<1>;
+export declare const kanbanIcon: import('lit').TemplateResult<1>;
+export declare const tableIcon: import('lit').TemplateResult<1>;
+export declare const sortOrderAscendIcon: import('lit').TemplateResult<1>;
+export declare const sortOrderDescendIcon: import('lit').TemplateResult<1>;

package/library/packages/organisms/src/text-to-speech/extensions/Break/break.d.ts

@@ -0,0 +1,4 @@
+import { Node } from '@tiptap/core';
+import { TuneOptions } from '../../../../../types/src/text-to-speech';
+
+export declare const Break: Node<TuneOptions, any>;

package/library/packages/organisms/src/text-to-speech/extensions/Break/index.d.ts

@@ -0,0 +1,4 @@
+import { Break } from './break';
+
+export * from './break';
+export default Break;

package/library/packages/organisms/src/text-to-speech/extensions/BubbleMenu/bubble-menu.d.ts

@@ -0,0 +1,68 @@
+import { Editor } from '@tiptap/core';
+import { EditorState, Plugin, PluginKey } from '@tiptap/pm/state';
+import { EditorView } from '@tiptap/pm/view';
+import { default as CxPopup } from '../../../../../atoms/src/components/popup/popup.ts';
+
+export interface BubbleMenuPluginProps {
+    /**
+     * The editor instance.
+     */
+    editor: Editor;
+    /**
+     * The DOM element that contains your menu.
+     * @type {HTMLElement}
+     * @default null
+     */
+    element: CxPopup;
+    /**
+     * The plugin key.
+     * @type {PluginKey | string}
+     * @default 'bubbleMenu'
+     */
+    pluginKey: PluginKey | string;
+    /**
+     * A function that determines whether the menu should be shown or not.
+     * If this function returns `false`, the menu will be hidden, otherwise it will be shown.
+     */
+    shouldShow?: ((props: {
+        editor: Editor;
+        from: number;
+        oldState?: EditorState;
+        state: EditorState;
+        to: number;
+        view: EditorView;
+    }) => boolean) | null;
+    /**
+     * The delay in milliseconds before the menu should be updated.
+     * This can be useful to prevent performance issues.
+     * @type {number}
+     * @default 250
+     */
+    updateDelay?: number;
+}
+export type BubbleMenuViewProps = BubbleMenuPluginProps & {
+    view: EditorView;
+};
+export declare class BubbleMenuView {
+    editor: Editor;
+    element: CxPopup;
+    view: EditorView;
+    preventHide: boolean;
+    updateDelay: number;
+    private updateDebounceTimer;
+    shouldShow: Exclude<BubbleMenuPluginProps['shouldShow'], null>;
+    constructor({ editor, element, shouldShow, updateDelay, view, }: BubbleMenuViewProps);
+    mousedownHandler: () => void;
+    dragstartHandler: () => void;
+    focusHandler: () => void;
+    blurHandler: ({ event }: {
+        event: FocusEvent;
+    }) => void;
+    update(view: EditorView, oldState?: EditorState): void;
+    handleDebouncedUpdate: (view: EditorView, oldState?: EditorState) => void;
+    updateHandler: (view: EditorView, selectionChanged: boolean, docChanged: boolean, oldState?: EditorState) => void;
+    show(): void;
+    hide(): void;
+    destroy(): void;
+}
+export declare const BubbleMenuPlugin: (options: BubbleMenuPluginProps) => Plugin<any>;

package/library/packages/organisms/src/text-to-speech/extensions/BubbleMenu/index.d.ts

@@ -0,0 +1,4 @@
+import { BubbleMenuPlugin } from './bubble-menu';
+
+export * from './bubble-menu';
+export default BubbleMenuPlugin;

package/library/packages/organisms/src/text-to-speech/extensions/CleanPaste/cleanPaste.d.ts

@@ -0,0 +1,3 @@
+import { Extension } from '@tiptap/core';
+
+export declare const CleanPaste: Extension<any, any>;

package/library/packages/organisms/src/text-to-speech/extensions/CleanPaste/index.d.ts

@@ -0,0 +1,4 @@
+import { CleanPaste } from './cleanPaste';
+
+export * from './cleanPaste';
+export default CleanPaste;

package/library/packages/organisms/src/text-to-speech/extensions/Selection/index.d.ts

@@ -0,0 +1,4 @@
+import { MockSelection } from './selection';
+
+export * from './selection';
+export default MockSelection;

package/library/packages/organisms/src/text-to-speech/extensions/Selection/selection.d.ts

@@ -0,0 +1,3 @@
+import { Extension } from '@tiptap/core';
+
+export declare const MockSelection: Extension<any, any>;

package/library/packages/organisms/src/text-to-speech/extensions/Tune/index.d.ts

@@ -0,0 +1 @@
+export * from './tune';

package/library/packages/organisms/src/text-to-speech/extensions/Tune/tune.d.ts

@@ -0,0 +1,7 @@
+import { Mark } from '@tiptap/core';
+import { TuneOptions } from '../../../../../types/src/text-to-speech';
+
+declare const Emphasis: Mark<TuneOptions, any>;
+declare const Prosody: Mark<TuneOptions, any>;
+declare const SayAs: Mark<TuneOptions, any>;
+export { Emphasis, Prosody, SayAs };

package/library/packages/organisms/src/text-to-speech/text-to-speech.api.d.ts

@@ -0,0 +1,10 @@
+import { Voice } from '../../../types/src/text-to-speech';
+
+export declare function getVoiceList(languageCode?: string, provider?: string): Promise<Voice[]>;
+export declare function previewVoice(text: string, languageCode: string | undefined, provider: string | undefined, voiceName: string, gender: 'MALE' | 'FEMALE'): Promise<Blob | {
+    errorMessage: string;
+}>;
+export declare function saveVoice(text: string, editorContent: string, languageCode: string | undefined, provider: string | undefined, voiceName: string, gender: 'MALE' | 'FEMALE', fileName: string, recordID: string): Promise<{
+    errorMessage: string;
+    success: boolean;
+}>;