builder-settings-types 0.0.462 → 0.0.464

package/dist/base/additional-settings/additonalSettings.d.ts

@@ -0,0 +1,42 @@
+import { SettingsMap } from '../../types';
+import { IDrawable } from '../drawable';
+export type AdditionalSettingsProps<TSettings extends SettingsMap> = {
+    title: string;
+    settings: TSettings;
+};
+export declare class AdditionalSettings<TSettings extends SettingsMap> implements IDrawable {
+    title: string;
+    private settings;
+    private selectedKeys;
+    private repeatingInstances;
+    private rootElement;
+    private contentElement;
+    private addButton;
+    private selector;
+    constructor(additionalSettingsProps: AdditionalSettingsProps<TSettings>);
+    draw(): HTMLElement;
+    getSettings(): TSettings;
+    getSelectedKeys(): (keyof TSettings)[];
+    setSelectedKeys(keys: (keyof TSettings)[]): void;
+    removeSettingKey(key: keyof TSettings): void;
+    addSettingKey(key: keyof TSettings): void;
+    /**
+     * Restore visible repeating instances for a key from serialized values.
+     * Clears existing instances for that key and re-creates from the array.
+     */
+    restoreRepeatingInstances(key: keyof TSettings, values: unknown[]): void;
+    private createHeader;
+    private createContentContainer;
+    private getRemainingKeys;
+    private selectSetting;
+    private addRepeatingInstance;
+    private removeRepeatingInstance;
+    private renderRepeatingInstance;
+    private clearRegularElements;
+    private removeSetting;
+    private renderSelectedSetting;
+    private getSettingTitle;
+    private attachAddButtonClickHandler;
+    private updateAddButtonState;
+    private updateSelectorOptions;
+}

package/dist/base/additional-settings/repeatingSetting.d.ts

@@ -0,0 +1,61 @@
+export type RepeatingSettingProps<T extends object> = {
+    title: string;
+    factory: () => T;
+    max?: number;
+};
+/** Sentinel wrapper written into getInstanceValues() for hidden instances. */
+export type RepeatingHiddenSentinel = {
+    __hidden: true;
+    value: unknown;
+};
+export declare function isRepeatingHiddenSentinel(v: unknown): v is RepeatingHiddenSentinel;
+export declare class RepeatingSetting<T extends object> {
+    readonly isRepeating: true;
+    readonly isAdditional: true;
+    title: string;
+    readonly factory: () => T;
+    readonly max: number;
+    private instances;
+    private onChangeCb?;
+    private restoreCallback?;
+    constructor(props: RepeatingSettingProps<T>);
+    canAddMore(): boolean;
+    createInstance(hidden?: boolean): {
+        id: string;
+        instance: T;
+    };
+    removeInstance(id: string): void;
+    /** Returns all instances (visible and hidden) in insertion order. */
+    getInstances(): {
+        id: string;
+        instance: T;
+    }[];
+    clearInstances(): void;
+    setInstanceHidden(id: string, hidden: boolean): void;
+    getInstanceHidden(id: string): boolean;
+    private extractInstanceValue;
+    private extractInstanceValueForJson;
+    /**
+     * Returns ALL instances in order, preserving hidden state.
+     * Hidden instances are wrapped: { __hidden: true, value: <instanceValue> }.
+     * This lets restoreFromValues reconstruct exact order + hidden state.
+     */
+    getInstanceValues(): unknown[];
+    /**
+     * Returns values for ALL instances.
+     * Hidden instances are wrapped: { __hidden: true, value: <instanceValue> }.
+     * This lets restoreFromValues reconstruct exact order + hidden state.
+     */
+    getInstanceValuesForJson(): unknown[];
+    setOnChange(cb: () => void): void;
+    setRestoreCallback(cb: (values: unknown[]) => void): void;
+    setValue(newValues: unknown[]): void;
+    notifyChange(): void;
+    /**
+     * Clears all instances and restores from values.
+     * Handles both plain values (visible) and sentinel-wrapped values (hidden),
+     * preserving the original order.
+     */
+    restoreFromValues(values: unknown[]): void;
+}
+export declare function isRepeatingSetting(value: unknown): value is RepeatingSetting<object>;

package/dist/base/drawable.d.ts

@@ -1,6 +1,17 @@
 export interface IDrawable {
     draw(): HTMLElement;
+    drawWithActions?(): HTMLElement;
 }
 export interface IChangable<T> {
     setOnChange(onChange: (value: T) => void): void;
 }
+export interface IActionable {
+    setIsHidden(hidden: boolean): void;
+    setIncludeInTree(include: boolean): void;
+    getIsHidden(): boolean;
+    getIncludeInTree(): boolean;
+    resetActionStates(options?: {
+        includeInTree?: boolean;
+        hide?: boolean;
+    }): void;
+}

package/dist/base/pendingSettingsGroup.d.ts

@@ -6,9 +6,7 @@ export interface PendingSettingsGroupProps<TSettings extends SettingsMap> extend
 }
 export declare class PendingSettingsGroup<TSettings extends SettingsMap> extends SettingGroup<TSettings> implements IDrawable, IChangable<ExtractSettingValues<TSettings>> {
     isRootNode: boolean;
-    isInitialized: boolean;
     pendingSettingValuesByKey: Record<string, ExtractSettingValues<TSettings>[keyof TSettings]>;
-    static readonly IGNORE_KEYS: string[];
     static readonly DEFAULT_KEYS: string[];
     constructor(groupProps: PendingSettingsGroupProps<TSettings>);
     setValue(newValue: ExtractSettingValues<TSettings>): void;

package/dist/base/settings-group/settingsGroup.d.ts

@@ -1,6 +1,9 @@
-import { IChangable, IDrawable } from '../drawable';
+import { IActionable, IChangable, IDrawable } from '../drawable';
 import { SettingsMap, SettingChild, SettingsProps, ExtractSettingValues, ExtractSettingValuesOptional, SettingChangeCallback, SettingBlurCallback, SerializedSettingValues, MobileSettingValues, SettingIteratorCallback } from '../../types/index';
 import { ParsedRule } from '../../services/ExcelRulesService';
+import { AdditionalSettings } from '../additional-settings/additonalSettings';
+import { Action, ActionType } from '../../components/actions/action';
+import { SettingGroupAction } from '../../components/actions/actionsCollection';
 export type ExcelImportConfig = {
     enabled: boolean;
     languages?: string[];
@@ -24,6 +27,7 @@ export type SettingGroupProps<TSettings extends SettingsMap> = {
     id?: string;
     title?: string;
     settings: TSettings;
+    additionalSettingsTitle?: string;
     collapsed?: boolean;
     main?: boolean;
     custom?: boolean;
@@ -34,22 +38,25 @@ export type SettingGroupProps<TSettings extends SettingsMap> = {
     hide?: boolean;
     setActiveOnSettingSelection?: boolean;
     disabled?: boolean;
+    actions?: SettingGroupAction[];
+    isAdditional?: boolean;
 };
 export declare function iterateSettings<TSettings extends SettingsMap>(settings: TSettings, callback: SettingIteratorCallback<TSettings>): void;
 export type SettingGroupWithSettings<TSettings extends SettingsMap> = SettingGroup<TSettings> & TSettings;
 export type TabSettingsGroupGenericType = Record<string, SettingGroup<SettingsMap>>;
-export declare class SettingGroup<TSettings extends SettingsMap> implements IDrawable, IChangable<ExtractSettingValues<TSettings>> {
+export declare class SettingGroup<TSettings extends SettingsMap> implements IDrawable, IChangable<ExtractSettingValues<TSettings>>, IActionable {
     title: string;
     settings: TSettings;
+    additionalSettings?: AdditionalSettings<TSettings>;
     id: string;
     onChange?: SettingChangeCallback<ExtractSettingValues<TSettings>> | undefined;
     onBlur?: SettingBlurCallback;
+    isAdditional: boolean;
     private isCollapsed;
     private isMain;
     private includeGetJson;
     private elementRef;
     private static hiddenElements;
-    private isHidden;
     private custom;
     initialValues: ExtractSettingValues<TSettings>;
     private changeTimeout;
@@ -66,6 +73,7 @@ export declare class SettingGroup<TSettings extends SettingsMap> implements IDra
     private dataProps?;
     private dataPropsPath;
     private hide;
+    private hideAsSetting;
     private isValueInProcessing;
     protected suppressOnChange: boolean;
     protected isRootNode: boolean;
@@ -76,12 +84,20 @@ export declare class SettingGroup<TSettings extends SettingsMap> implements IDra
     detectChange?: () => void;
     private disabled?;
     private groupContainer?;
+    actionsByType: Map<ActionType, Action>;
+    private includeInTree;
+    private excludeFromUI;
+    private additionalSettingsMap;
+    private static EXTRA_SETTINGS_KEYS;
     constructor(groupProps: SettingGroupProps<TSettings>);
+    private buildAdditionalSettingsMap;
+    private isAdditionalKey;
     private propagateNestingLevel;
     consumeSkipHistoryNextChange(): boolean;
     getNestingLevel(): number;
     setNestingLevel(level: number): void;
     setTitle(title: string): void;
+    setActions(actions: Action[]): void;
     getDataPropsPath(): string;
     setDataPropsPath(path: string): void;
     private propagateDataPropsPath;
@@ -100,6 +116,7 @@ export declare class SettingGroup<TSettings extends SettingsMap> implements IDra
     getMobileValues<K extends keyof TSettings>(childKey: K): unknown;
     setOnChange(onChange: SettingChangeCallback<ExtractSettingValues<TSettings>>): SettingGroup<TSettings>;
     cleanup(): void;
+    private setExtraSettingValue;
     setValue(values: ExtractSettingValuesOptional<TSettings>): void;
     private wireChild;
     addSetting<T extends SettingsProps>(key: string, setting: SettingChild<T>): void;
@@ -124,8 +141,18 @@ export declare class SettingGroup<TSettings extends SettingsMap> implements IDra
     draw(): HTMLElement;
     collapse(): void;
     expand(): void;
+    getIncludeInTree(): boolean;
+    getIsHidden(): boolean;
     getJson(): string;
     setJson(jsonString: string): void;
+    setIsCollapsed(collapsed: boolean): void;
+    setIncludeInTree(include: boolean): void;
+    setIsHidden(hidden: boolean): void;
+    resetActionStates({ includeInTree, hide, collapsed }?: {
+        includeInTree?: boolean;
+        hide?: boolean;
+        collapsed?: boolean;
+    }): void;
 }
 export declare class RootSettingGroup<TSettings extends SettingsMap> extends SettingGroup<TSettings> implements IDrawable, IChangable<ExtractSettingValues<TSettings>> {
     constructor(groupProps: SettingGroupProps<TSettings>);

package/dist/base/settings.d.ts

@@ -1,4 +1,6 @@
-import { IChangable, IDrawable } from './drawable';
+import { IActionable, IChangable, IDrawable } from './drawable';
+import { Action } from '../components/actions/action';
+import { SettingAction } from '../components/actions/actionsCollection';
 export interface SettingProps<T> {
     default?: T;
     title?: string;
@@ -10,6 +12,8 @@ export interface SettingProps<T> {
     detectChangeButOneThatReallyWorks?: (value: T | undefined) => void;
     includeGetJson?: boolean;
     description?: string;
+    actions?: SettingAction[];
+    isAdditional?: boolean;
 }
 export type Primitive = string | number | boolean | symbol | bigint | null | undefined;
 export type InputTypes = 'number' | 'text' | 'select' | 'color' | 'date' | 'button';
@@ -29,7 +33,7 @@ export type FontItem = {
     fontName: string;
     fontUrl: string;
 };
-export declare abstract class Setting<T, P extends SettingProps<T>> implements IDrawable, IChangable<T> {
+export declare abstract class Setting<T, P extends SettingProps<T>> implements IDrawable, IChangable<T>, IActionable {
     protected props: P;
     static DefaultUploadUrl: string;
     static DefaultLanguage: string;
@@ -55,15 +59,29 @@ export declare abstract class Setting<T, P extends SettingProps<T>> implements I
     title: string | undefined;
     desktop: T | undefined;
     includeGetJson: boolean;
+    isAdditional: boolean;
     private dataPropsPath;
+    private actionsByType;
+    private hide;
+    private includeInTree;
     abstract inputType: T extends Primitive ? InputTypes : Record<keyof T, InputTypes>;
     onChange: ((value: T) => void) | undefined;
     onBlur: ((value: T) => void) | undefined;
     constructor(props?: P);
+    setActions(actions: Action[]): void;
+    drawWithActions(): HTMLElement;
     setOnChange(onChange: (value: T) => void): Setting<T, P>;
     setOnBlur(onBlur: (value: T) => void): Setting<T, P>;
     setDataPropsPath(path: string): void;
+    setIsHidden(hidden: boolean): void;
+    setIncludeInTree(include: boolean): void;
+    resetActionStates({ includeInTree, hide }?: {
+        includeInTree?: boolean;
+        hide?: boolean;
+    }): void;
     getDataPropsPath(): string;
+    getIsHidden(): boolean;
+    getIncludeInTree(): boolean;
     /**
      * Set the component path for this setting (used for hierarchical identification)
      * Override in subclasses that need this functionality