builder-settings-types 0.0.224 → 0.0.229

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/settings/align-settings/alignSettings.d.ts

@@ -0,0 +1,9 @@
+import { Setting, SettingProps, InputTypes } from '../../base/settings';
+export type AlignValue = "left" | "center" | "right";
+export interface AlignSettingProps extends SettingProps<AlignValue> {
+}
+export declare class AlignSetting extends Setting<AlignValue, AlignSettingProps> {
+    inputType: InputTypes;
+    constructor(props?: AlignSettingProps);
+    draw(): HTMLElement;
+}

package/dist/settings/animation-settings/animationSettings.d.ts

@@ -0,0 +1,12 @@
+import { Setting, SettingProps, InputTypes } from '../../base/settings';
+export type AnimationValue = "fade" | "slide" | "zoom" | "bounce" | "pulse" | "none";
+export interface AnimationSettingProps extends SettingProps<AnimationValue> {
+    title?: string;
+}
+export declare class AnimationSetting extends Setting<AnimationValue, AnimationSettingProps> {
+    inputType: InputTypes;
+    private selectSetting;
+    constructor(props?: AnimationSettingProps);
+    draw(): HTMLElement;
+    destroy(): void;
+}

package/dist/settings/button-settings/buttonSettings.d.ts

@@ -0,0 +1,16 @@
+import { InputTypes, Setting, SettingProps } from '../../base/settings';
+export interface ButtonSettingProps extends SettingProps<void> {
+    label: string;
+    onClick?: () => void;
+    className?: string;
+    wrapperClassName?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    borderColor?: string;
+}
+export declare class ButtonSetting extends Setting<void, ButtonSettingProps> {
+    inputType: InputTypes;
+    constructor(props: ButtonSettingProps);
+    bgWithAlpha: string;
+    draw(): HTMLElement;
+}

package/dist/settings/color-settings/colorSettings.d.ts

@@ -0,0 +1,23 @@
+import { InputTypes } from '../../base/settings';
+import { StringSetting, StringSettingsProps } from '../string-settings/stringSettings';
+export interface ColorSettingProps extends StringSettingsProps {
+    detectChange?: (value: string | undefined) => void;
+}
+export declare class ColorSetting extends StringSetting {
+    inputType: InputTypes;
+    detectChange?: (value: string | undefined) => void;
+    private element;
+    private colorInputEl;
+    private textInputEl;
+    constructor(props: ColorSettingProps);
+    private static normalizeColorValue;
+    private static normalizeHexValue;
+    private static rgbToHexStatic;
+    setValue(newValue: string | undefined): void;
+    private hexToRgb;
+    draw(): HTMLElement;
+    getElement(): HTMLElement | null;
+    getNormalizedValue(): string;
+    isValidHex(): boolean;
+    toRgb(): string;
+}

package/dist/settings/color-with-opacity-settings/colorWithOpacitySettings.d.ts

@@ -0,0 +1,33 @@
+import { InputTypes, Setting, SettingProps } from '../../base/settings';
+export interface ColorWithOpacitySettingProps extends SettingProps<string> {
+    detectChange?: (value: string | undefined) => void;
+    wrapperClassName?: string;
+}
+export declare class ColorWithOpacitySetting extends Setting<string, ColorWithOpacitySettingProps> {
+    inputType: InputTypes;
+    detectChange?: (value: string | undefined) => void;
+    private element;
+    private colorInputEl;
+    private textInputEl;
+    private opacityInputEl;
+    private colorPreviewEl;
+    constructor(props?: ColorWithOpacitySettingProps);
+    private static normalizeHexWithOpacity;
+    private getRgbColor;
+    private getOpacityPercent;
+    private static combineColorOpacity;
+    setValue(newValue: string | undefined): void;
+    private updateInputElements;
+    private updateColorPreview;
+    private handleColorChange;
+    private handleTextInput;
+    private handleOpacityChange;
+    draw(): HTMLElement;
+    getElement(): HTMLElement | null;
+    getValue(): string | undefined;
+    getRgbaValue(): string;
+    getColorAndOpacity(): {
+        color: string;
+        opacity: number;
+    };
+}

package/dist/settings/gap-settings/gapSettings.d.ts

@@ -0,0 +1,26 @@
+import { InputTypes, Setting, SettingProps } from '../../base/settings';
+export type GapSuffix = "px" | "em" | "rem" | "%" | "vh" | "vw" | "pt" | "none";
+export interface GapSettingsProps extends SettingProps<number> {
+    minValue?: number;
+    maxValue?: number;
+    step?: number;
+    suffix?: GapSuffix;
+    className?: string;
+    inputClassName?: string;
+    wrapperClassName?: string;
+    rowGap?: boolean;
+    columnGap?: boolean;
+    onBlur?: () => void;
+    mobile?: number;
+}
+export declare class GapSetting extends Setting<number, GapSettingsProps> {
+    inputType: InputTypes;
+    private inputValues;
+    mobileValue?: number;
+    constructor(props?: GapSettingsProps);
+    draw(): HTMLElement;
+    private createGapInput;
+    private validateValue;
+    getMobileValue(): number | undefined;
+    setMobileValue(value: number | undefined): void;
+}

package/dist/settings/height-setting/heightSettings.d.ts

@@ -0,0 +1,12 @@
+import { InputTypes } from '../../base/settings';
+import { NumberSetting, NumberSettingsProps } from '../number-settings/numberSettings';
+export type HeightSettingProps = NumberSettingsProps & {
+    mobile?: number;
+};
+export declare class HeightSetting extends NumberSetting {
+    inputType: InputTypes;
+    mobileValue?: number;
+    constructor(props?: HeightSettingProps);
+    getMobileValue(): number | undefined;
+    setMobileValue(value: number | undefined): void;
+}

package/dist/settings/html-settings/htmlSettings.d.ts

@@ -0,0 +1,18 @@
+import { InputTypes, Setting, SettingProps } from '../../base/settings';
+export interface HtmlSettingsProps extends SettingProps<string> {
+    maxLength?: number;
+    value?: string;
+    className?: string;
+    textareaClassName?: string;
+    wrapperClassName?: string;
+    rows?: number;
+    placeholder?: string;
+    onChange?: (value: string) => void;
+}
+export declare class HtmlSetting extends Setting<string, HtmlSettingsProps> {
+    inputType: InputTypes;
+    private textareaEl?;
+    constructor(props?: HtmlSettingsProps);
+    setValue(newValue: string): void;
+    draw(): HTMLElement;
+}

package/dist/settings/html-settings/index.d.ts

@@ -0,0 +1 @@
+export { HtmlSetting, type HtmlSettingsProps } from './htmlSettings';

package/dist/settings/margin-bottom-settings/marginBottomSettings.d.ts

@@ -0,0 +1,8 @@
+import { InputTypes } from '../../base/settings';
+import { NumberSetting, NumberSettingsProps } from '../number-settings/numberSettings';
+export interface MarginBottomSettingsProps extends NumberSettingsProps {
+}
+export declare class MarginBottomSetting extends NumberSetting {
+    inputType: InputTypes;
+    constructor(props?: MarginBottomSettingsProps);
+}

package/dist/settings/margin-top-settings/marginTopSettings.d.ts

@@ -0,0 +1,8 @@
+import { InputTypes } from '../../base/settings';
+import { NumberSetting, NumberSettingsProps } from '../number-settings/numberSettings';
+export interface MarginTopSettingsProps extends NumberSettingsProps {
+}
+export declare class MarginTopSetting extends NumberSetting {
+    inputType: InputTypes;
+    constructor(props?: MarginTopSettingsProps);
+}

package/dist/settings/multi-language-settings/multiLanguageSettings.d.ts

@@ -0,0 +1,32 @@
+import { Setting, SettingProps } from '../../base/settings';
+export interface MultiLanguageValue {
+    [languageCode: string]: string;
+}
+export interface MultiLanguageSettingsProps extends SettingProps<MultiLanguageValue> {
+    availableLanguages?: Array<{
+        code: string;
+        name: string;
+    }>;
+    maxLanguages?: number;
+    placeholder?: string;
+}
+export declare class MultiLanguageSetting extends Setting<MultiLanguageValue, MultiLanguageSettingsProps> {
+    inputType: Record<keyof MultiLanguageValue, "text">;
+    private container;
+    private languagesContainer;
+    private addLanguageSelect;
+    private addButton;
+    private defaultLanguages;
+    constructor(props?: MultiLanguageSettingsProps);
+    private get availableLanguages();
+    private get usedLanguageCodes();
+    private get availableLanguageOptions();
+    private updateAddLanguageSelect;
+    private createLanguageRow;
+    private updateLanguageValue;
+    private removeLanguage;
+    private addLanguage;
+    private createAddLanguageSection;
+    draw(): HTMLElement;
+    setValue(value: MultiLanguageValue): void;
+}

package/dist/settings/number-settings/numberSettings.d.ts

@@ -0,0 +1,25 @@
+import { InputTypes, Setting, SettingProps } from '../../base/settings';
+export type NumberSuffix = "px" | "em" | "rem" | "%" | "vh" | "vw" | "pt" | "none";
+export interface NumberSettingsProps extends SettingProps<number> {
+    minValue?: number;
+    maxValue?: number;
+    step?: number;
+    className?: string;
+    inputClassName?: string;
+    wrapperClassName?: string;
+    suffix?: NumberSuffix;
+    mobile?: number;
+    onBlur?: () => void;
+}
+export declare class NumberSetting extends Setting<number, NumberSettingsProps> {
+    inputType: InputTypes;
+    private inputElement;
+    mobileValue?: number;
+    constructor(props: NumberSettingsProps);
+    draw(): HTMLElement;
+    setValue(value: number | undefined): void;
+    private validateValue;
+    getMobileValue(): number | undefined;
+    setMobileValue(value: number | undefined): void;
+    private validateProps;
+}

package/dist/settings/opacity-settings/opacitySettings.d.ts

@@ -0,0 +1,12 @@
+import { InputTypes } from '../../base/settings';
+import { NumberSetting, NumberSettingsProps as NumberSettingProps } from '../number-settings/numberSettings';
+export type OpacitySettingProps = NumberSettingProps & {
+    mobile?: number;
+};
+export declare class OpacitySetting extends NumberSetting {
+    inputType: InputTypes;
+    mobileValue?: number;
+    constructor(props?: OpacitySettingProps);
+    getMobileValue(): number | undefined;
+    setMobileValue(value: number | undefined): void;
+}

package/dist/settings/select-api/select-api.d.ts

@@ -0,0 +1,37 @@
+import { Setting, SettingProps, InputTypes, Primitive } from '../../base/settings';
+export interface SelectApiOption {
+    name: string;
+    value: string | object;
+}
+export interface SelectApiSettingProps<T = any> extends SettingProps<T> {
+    options?: SelectApiOption[];
+    getOptions?: () => SelectApiOption[];
+    getOptionsAsync?: () => Promise<SelectApiOption[]>;
+    loadingText?: string;
+    errorText?: string;
+    onChange?: (value: T) => void;
+    detectChange?: (value: T | undefined) => void;
+}
+export declare class SelectApiSettings<T = any> extends Setting<T, SelectApiSettingProps<T>> {
+    inputType: T extends Primitive ? InputTypes : Record<keyof T, InputTypes>;
+    private _options;
+    private isOpen;
+    private selectedOptionIndex;
+    private optionsListEl;
+    private svgContainer;
+    private buttonEl;
+    private isLoading;
+    private container;
+    private hasInitializedOptions;
+    private detectChangeCallback?;
+    constructor(props?: SelectApiSettingProps<T>);
+    private initializeOptions;
+    private createOption;
+    draw(): HTMLElement;
+    getJson(excludeSelectSettings?: boolean): string;
+    private selectApiOption;
+    private updateOptionsList;
+    private updateButtonText;
+    setDetectChange(callback: (value: T | undefined) => void): void;
+    setValue(value: T): void;
+}

package/dist/settings/select-settings/selectSettings.d.ts

@@ -0,0 +1,41 @@
+import { Setting, SettingProps, InputTypes, Primitive } from '../../base/settings';
+export interface SelectOption {
+    name: string;
+    value: string | object;
+}
+export interface SelectSettingProps<T = any> extends SettingProps<T> {
+    options?: SelectOption[];
+    getOptions?: () => SelectOption[];
+    getOptionsAsync?: () => Promise<SelectOption[]>;
+    loadingText?: string;
+    placeholder?: string;
+}
+export declare class SelectSetting<T = any> extends Setting<T, SelectSettingProps<T>> {
+    inputType: T extends Primitive ? InputTypes : Record<keyof T, InputTypes>;
+    private _options;
+    private isOpen;
+    private selectedOptionIndex;
+    private optionsListEl;
+    private svgContainer;
+    private buttonEl;
+    private isLoading;
+    private container;
+    private clickOutsideListener;
+    private resizeListener;
+    constructor(props?: SelectSettingProps<T>);
+    setValue(newValue: T): void;
+    private createOption;
+    draw(): HTMLElement;
+    /**
+     * Check if dropdown should be positioned above the button
+     */
+    private checkDropdownPosition;
+    private selectOption;
+    /**
+     * Clean up dropdown positioning when closed
+     */
+    private cleanupDropdownPosition;
+    private updateOptionsList;
+    private updateButtonText;
+    destroy(): void;
+}

package/dist/settings/size-setting/dimensionSettings.d.ts

@@ -0,0 +1,38 @@
+import { Setting, SettingProps } from '../../base/settings';
+export interface DimensionValue {
+    width: number;
+    height: number;
+}
+export interface DimensionSettingProps extends SettingProps<DimensionValue> {
+    locked?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    width?: number;
+    height?: number;
+}
+export declare class DimensionSetting extends Setting<DimensionValue, DimensionSettingProps> {
+    inputType: {
+        readonly width: "number";
+        readonly height: "number";
+    };
+    private widthSetting;
+    private heightSetting;
+    private minWidth;
+    private maxWidth?;
+    private minHeight;
+    private maxHeight?;
+    private locked;
+    private aspectRatio;
+    private isUpdating;
+    constructor(props?: DimensionSettingProps);
+    private handleWidthChange;
+    private handleHeightChange;
+    private toggleLock;
+    private getLockSVG;
+    setValue(newValue: DimensionValue): void;
+    draw(): HTMLElement;
+    isLocked(): boolean;
+    setLocked(locked: boolean): void;
+}

package/dist/settings/string-settings/stringSettings.d.ts

@@ -0,0 +1,14 @@
+import { InputTypes, Setting, SettingProps } from '../../base/settings';
+export interface StringSettingsProps extends SettingProps<string> {
+    maxLength?: number;
+    value?: string;
+    className?: string;
+    inputClassName?: string;
+    wrapperClassName?: string;
+    onChange?: (value: string) => void;
+}
+export declare class StringSetting extends Setting<string, StringSettingsProps> {
+    inputType: InputTypes;
+    constructor(props?: StringSettingsProps);
+    draw(): HTMLElement;
+}

package/dist/settings/toggle-settings/index.d.ts

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

package/dist/settings/toggle-settings/toggleSettings.d.ts

@@ -0,0 +1,21 @@
+import { InputTypes, Setting, SettingProps } from '../../base/settings';
+export interface ToggleValue {
+    value: string;
+    status: boolean;
+}
+export interface ToggleSettingProps extends SettingProps<string> {
+    title?: string;
+    icon?: string;
+    default?: string;
+    options?: ToggleValue[];
+    activeColor?: string;
+    inactiveColor?: string;
+    detectChange?: (value: string | undefined) => void;
+}
+export declare class Toggle extends Setting<string, ToggleSettingProps> {
+    inputType: InputTypes;
+    private detectChangeCallback?;
+    constructor(props: ToggleSettingProps);
+    draw(): HTMLElement;
+    setDetectChange(callback: (value: string | undefined) => void): void;
+}

package/dist/settings/upload-image-settings/uploadImageSettings.d.ts

@@ -0,0 +1,31 @@
+import { Setting, SettingProps, InputTypes } from '../../base/settings';
+export interface UploadSettingProps extends SettingProps<string> {
+    defaultUrl?: string;
+    delete?: boolean;
+    uploadUrl?: string;
+    requestMethod?: string;
+    requestHeaders?: Record<string, string>;
+    formFieldName?: string;
+    parseResponse?: (responseData: unknown) => string;
+    maxFileSizeMB?: number;
+}
+export declare class UploadSetting extends Setting<string, UploadSettingProps> {
+    inputType: InputTypes;
+    private previewWrapper;
+    private previewEl;
+    private emptyStateEl;
+    private errorContainer;
+    private messageListener;
+    private loadingSpinner;
+    constructor(props?: UploadSettingProps);
+    private setupMessageListener;
+    private cleanupMessageListener;
+    destroy(): void;
+    private showError;
+    private hideError;
+    private showLoading;
+    private hideLoading;
+    private validateFileSize;
+    private updatePreviewState;
+    draw(): HTMLElement;
+}

package/dist/settings/width-setting/widthSettings.d.ts

@@ -0,0 +1,12 @@
+import { InputTypes } from '../../base/settings';
+import { NumberSetting, NumberSettingsProps } from '../number-settings/numberSettings';
+export type WidthSettingProps = NumberSettingsProps & {
+    mobile?: number;
+};
+export declare class WidthSetting extends NumberSetting {
+    inputType: InputTypes;
+    mobileValue?: number;
+    constructor(props?: WidthSettingProps);
+    getMobileValue(): number | undefined;
+    setMobileValue(value: number | undefined): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,34 @@
+import { Setting, SettingProps } from '../base/settings';
+import { SettingGroup } from '../base/settings-group/settingsGroup';
+export type SettingValue = string | number | boolean | null | undefined;
+export type ComplexSettingValue = SettingValue | Record<string, SettingValue> | Array<SettingValue> | Date;
+export type AnySettingValue = SettingValue | ComplexSettingValue;
+export type SettingInstance<T extends AnySettingValue = AnySettingValue> = Setting<T, SettingProps<T>>;
+export type SettingChild<T extends AnySettingValue = AnySettingValue> = SettingInstance<T> | SettingGroup<any>;
+export type SettingsMap = Record<string, Setting<any, any> | SettingGroup<any>>;
+export type SettingGroupInstance<TSettings extends SettingsMap = SettingsMap> = SettingGroup<TSettings>;
+export type ExtractSettingValue<T> = T extends Setting<infer V, any> ? V : never;
+export type ExtractSettingValues<TSettings extends SettingsMap> = {
+    readonly [K in keyof TSettings]: TSettings[K] extends Setting<infer V, any> ? V : TSettings[K] extends SettingGroup<infer S> ? ExtractSettingValues<S> : unknown;
+};
+export type ExtractSettingValuesOptional<TSettings extends SettingsMap> = {
+    [K in keyof TSettings]?: TSettings[K] extends Setting<infer V, any> ? V : TSettings[K] extends SettingGroup<infer S> ? ExtractSettingValuesOptional<S> : unknown;
+};
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type SettingChangeCallback<T> = (value: T) => void;
+export type SettingBlurCallback = () => void;
+export type SerializedSettingValues = Record<string, unknown>;
+export type MobileSettingValues<TSettings extends SettingsMap> = {
+    [K in keyof TSettings]?: TSettings[K] extends Setting<infer V, any> ? V : TSettings[K] extends SettingGroup<infer S> ? MobileSettingValues<S> : unknown;
+};
+export type SettingChanges<TSettings extends SettingsMap> = ExtractSettingValuesOptional<TSettings>;
+export declare function isSetting(value: unknown): value is SettingInstance;
+export declare function isSettingGroup(value: unknown): value is SettingGroupInstance;
+export declare function isSettingChild(value: unknown): value is SettingChild;
+export type SettingIteratorCallback<TSettings extends SettingsMap> = (key: keyof TSettings, setting: TSettings[typeof key]) => void;
+export type SettingsToProps<T> = T extends SettingGroup<infer S> ? ExtractSettingValues<S> : T extends {
+    getValues(): infer R;
+} ? R : never;
+export type { Setting, SettingGroup };

package/dist/utils/deepClone.d.ts

@@ -0,0 +1 @@
+export declare function deepClone<T>(obj: T): T;

package/dist/utils/nestingCalculator.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Nesting Calculator Utility
+ *
+ * This module provides functions to automatically calculate and apply
+ * nesting levels to setting groups based on their DOM hierarchy or
+ * programmatic structure.
+ */
+/**
+ * Calculate nesting level from DOM hierarchy
+ */
+export declare function calculateDOMNestingLevel(element: HTMLElement): number;
+/**
+ * Apply nesting styles to an element based on level
+ */
+export declare function applyNestingStyles(element: HTMLElement, level: number): void;
+/**
+ * Recursively apply nesting levels to all child setting groups
+ */
+export declare function applyNestingToChildren(container: HTMLElement, parentLevel?: number): void;
+/**
+ * Auto-detect and apply nesting for all setting groups in a container
+ */
+export declare function autoDetectAndApplyNesting(container?: HTMLElement): void;
+/**
+ * Calculate nesting level from object structure
+ */
+export declare function calculateStructuralNestingLevel(settingPath: string[]): number;
+/**
+ * Nesting level configuration
+ */
+export interface NestingConfig {
+    maxLevel: number;
+    spacingMultiplier: number;
+    visualIndentMultiplier: number;
+    enableAutoDetection: boolean;
+}
+export declare const DEFAULT_NESTING_CONFIG: NestingConfig;
+/**
+ * Nesting Calculator class for more advanced usage
+ */
+export declare class NestingCalculator {
+    private config;
+    private observedElements;
+    private observer?;
+    constructor(config?: Partial<NestingConfig>);
+    /**
+     * Setup automatic detection using MutationObserver
+     */
+    private setupAutoDetection;
+    /**
+     * Add element to be tracked for nesting updates
+     */
+    trackElement(element: HTMLElement): void;
+    /**
+     * Remove element from tracking
+     */
+    untrackElement(element: HTMLElement): void;
+    /**
+     * Update nesting for a specific element
+     */
+    updateElementNesting(element: HTMLElement): void;
+    /**
+     * Update nesting for all tracked elements
+     */
+    updateAllNesting(): void;
+    /**
+     * Apply nesting with configuration
+     */
+    private applyNestingWithConfig;
+    /**
+     * Force recalculate all nesting in a container
+     */
+    recalculateNesting(container?: HTMLElement): void;
+    /**
+     * Get nesting statistics for debugging
+     */
+    getNestingStats(): {
+        [level: number]: number;
+    };
+    /**
+     * Cleanup observer and tracked elements
+     */
+    destroy(): void;
+}
+/**
+ * Global nesting calculator instance
+ */
+export declare const globalNestingCalculator: NestingCalculator;
+/**
+ * Convenience function to enable automatic nesting detection
+ */
+export declare function enableAutoNesting(config?: Partial<NestingConfig>): void;
+/**
+ * Convenience function to disable automatic nesting detection
+ */
+export declare function disableAutoNesting(): void;

package/dist/utils/settingsTypes.d.ts

@@ -0,0 +1,13 @@
+import { ExtractSettingValues as NewExtractSettingValues, DeepPartial as NewDeepPartial, SettingsMap, SettingChild } from '../types/index';
+export * from '../types/index';
+export type SettingsToProps<T> = T extends {
+    getValues(): infer R;
+} ? R : never;
+export type InferSettingsProps<T> = T extends {
+    getValues(): infer R;
+} ? R : never;
+/** @deprecated Use DeepPartial from "../../types" instead */
+export type SettingsToPropsOptional<T> = NewDeepPartial<NewExtractSettingValues<T extends SettingsMap ? T : never>>;
+export declare function isSettingGroup(value: unknown): value is SettingChild;
+/** @deprecated Use isSetting from "../../types" instead */
+export declare function isSetting(value: unknown): value is SettingChild;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "builder-settings-types",
   "description": "builder settings",
-  "version": "0.0.224",
+  "version": "0.0.229",
   "type": "module",
   "main": "dist/builder-settings-types.cjs.js",
   "module": "dist/builder-settings-types.es.js",