builder-settings-types 0.0.227 → 0.0.229

package/dist/base/drawable.d.ts

@@ -0,0 +1,6 @@
+export interface IDrawable {
+    draw(): HTMLElement;
+}
+export interface IChangable<T> {
+    setOnChange(onChange: (value: T) => void): void;
+}

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

@@ -0,0 +1,7 @@
+import { IDrawable, IChangable } from './drawable';
+export interface ISettingsContainer<T> extends IDrawable, IChangable<T> {
+    getValues(): T;
+    setOnChange(onChange: (value: T) => void): ISettingsContainer<T>;
+    setOnBlur(onBlur: () => void): ISettingsContainer<T>;
+    draw(): HTMLElement;
+}

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

@@ -0,0 +1,100 @@
+import { IChangable, IDrawable } from '../drawable';
+import { SettingsMap, SettingChild, ExtractSettingValues, ExtractSettingValuesOptional, SettingChangeCallback, SettingBlurCallback, MobileSettingValues, SettingIteratorCallback } from '../../types/index';
+export type AddItemConfig<TSettings extends SettingsMap> = {
+    buttonLabel?: string;
+    keyPrefix: string;
+    createItem: (index: number) => SettingChild;
+};
+export type DeleteItemConfig = {
+    keyPrefix?: string;
+    showDeleteButton?: boolean;
+    deleteButtonLabel?: string;
+};
+export type SettingGroupProps<TSettings extends SettingsMap> = {
+    id?: string;
+    title: string;
+    settings: TSettings;
+    collapsed?: boolean;
+    main?: boolean;
+    custom?: boolean;
+    includeGetJson?: boolean;
+    addItem?: AddItemConfig<TSettings>;
+    deleteItem?: DeleteItemConfig;
+};
+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>> {
+    title: string;
+    settings: TSettings;
+    id: string;
+    onChange?: SettingChangeCallback<ExtractSettingValues<TSettings>> | undefined;
+    onBlur?: SettingBlurCallback;
+    private isCollapsed;
+    private isMain;
+    private includeGetJson;
+    private elementRef;
+    private static hiddenElements;
+    private isHidden;
+    private custom;
+    initialValues: ExtractSettingValues<TSettings>;
+    private changeTimeout;
+    private isHandlingChange;
+    private changeHandlers;
+    private blurTimeout;
+    private lastChangeTime;
+    private handleBlur;
+    private pendingBlurHandler;
+    private originalDefaultValues;
+    private nestingLevel;
+    private addItemCfg?;
+    private deleteItemCfg?;
+    constructor(groupProps: SettingGroupProps<TSettings>);
+    private propagateNestingLevel;
+    getNestingLevel(): number;
+    setNestingLevel(level: number): void;
+    private updateNestingStyles;
+    private forceChildUIRefresh;
+    removeSetting(key: string): void;
+    updateVisibility(): void;
+    clone(): SettingGroupWithSettings<TSettings>;
+    resetDefault(): void;
+    setMobileValues(values: MobileSettingValues<TSettings>): void;
+    getMobileValues(): MobileSettingValues<TSettings>;
+    getMobileValues<K extends keyof TSettings>(childKey: K): unknown;
+    setOnChange(onChange: SettingChangeCallback<ExtractSettingValues<TSettings>>): SettingGroup<TSettings>;
+    cleanup(): void;
+    setValue(values: ExtractSettingValuesOptional<TSettings>): void;
+    private wireChild;
+    addSetting(key: string, setting: SettingChild): void;
+    private addDeleteButtonToElement;
+    private showDeleteConfirmation;
+    private getNextIndexFromPrefix;
+    calculateChanges(oldValues: ExtractSettingValues<TSettings>, newValues: ExtractSettingValues<TSettings>): Record<string, {
+        from: unknown;
+        to: unknown;
+    }>;
+    getValues(): ExtractSettingValues<TSettings>;
+    getValues<K extends keyof TSettings>(childKey: K): unknown;
+    private getValuesForJson;
+    getDefaultValues(): ExtractSettingValues<TSettings>;
+    getDefaultValues<K extends keyof TSettings>(childKey: K): unknown;
+    draw(): HTMLElement;
+    collapse(): void;
+    expand(): void;
+    getJson(): string;
+    setJson(jsonString: string): void;
+}
+export declare function createTabSettingGroup<TSettings extends SettingsMap = SettingsMap>(groupProps: SettingGroupProps<TSettings>): TabSettingGroup<TSettings>;
+export declare class TabSettingGroup<TSettings extends SettingsMap = SettingsMap> extends SettingGroup<TSettings> {
+    private activeTabId;
+    private tabsContainer?;
+    private contentContainers?;
+    constructor(groupProps: SettingGroupProps<TSettings>);
+    getActiveTabId(): string;
+    switchToTab(tabId: string): void;
+    private updateTabUI;
+    draw(): HTMLElement;
+}
+export declare function createSettingGroup<TSettings extends SettingsMap>(groupProps: SettingGroupProps<TSettings>): SettingGroupWithSettings<TSettings>;
+export declare function asSettingGroupWithSettings<TSettings extends SettingsMap>(settingGroup: SettingGroup<TSettings>): SettingGroupWithSettings<TSettings>;

package/dist/base/settings.d.ts

@@ -0,0 +1,49 @@
+import { IChangable, IDrawable } from './drawable';
+export interface SettingProps<T> {
+    default?: T;
+    title?: string;
+    placeholder?: string;
+    icon?: string;
+    inputProps?: InputProps;
+    id?: string;
+    detectChange?: (value: T | undefined) => void;
+    includeGetJson?: boolean;
+}
+export type Primitive = string | number | boolean | symbol | bigint | null | undefined;
+export type InputTypes = "number" | "text" | "select" | "color" | "date" | "button";
+export type InputProps = {
+    iconClassName?: string;
+    labelClassName?: string;
+    value: unknown;
+    inputType: InputTypes;
+    title?: string;
+    icon?: string;
+    inputCustomizer?: (input: HTMLInputElement) => void;
+    inputClassName?: string;
+    wrapperClassName?: string;
+    placeholder?: string;
+};
+export declare abstract class Setting<T, P extends SettingProps<T>> implements IDrawable, IChangable<T> {
+    protected props: P;
+    static DefaultUploadUrl: string;
+    static SetUploadUrl(url: string): void;
+    destroy(): void;
+    protected inputEl?: HTMLInputElement;
+    id: string;
+    value: T | undefined;
+    title: string | undefined;
+    desktop: T | undefined;
+    includeGetJson: boolean;
+    abstract inputType: T extends Primitive ? InputTypes : Record<keyof T, InputTypes>;
+    onChange: ((value: T) => void) | undefined;
+    onBlur: ((value: T) => void) | undefined;
+    constructor(props?: P);
+    setOnChange(onChange: (value: T) => void): Setting<T, P>;
+    setOnBlur(onBlur: (value: T) => void): Setting<T, P>;
+    setValue(newValue: T): void;
+    clone(): Setting<T, P>;
+    abstract draw(): HTMLElement;
+    createInput(props: InputProps): HTMLElement;
+    createLabel(title: string, className?: string): HTMLSpanElement;
+    createIcon(icon: string, className?: string): HTMLSpanElement;
+}

package/dist/groups/background-setting-set/backgroundSettingsSet.d.ts

@@ -0,0 +1,19 @@
+import { SettingGroup } from '../../base/settings-group/settingsGroup';
+import { ColorWithOpacitySetting } from '../../settings/color-with-opacity-settings/colorWithOpacitySettings';
+import { OpacitySetting } from '../../settings/opacity-settings/opacitySettings';
+import { UploadSetting, UploadSettingProps } from '../../settings/upload-image-settings/uploadImageSettings';
+export declare class BackgroundSettingSet extends SettingGroup<{
+    backgroundImage: UploadSetting;
+    opacity: OpacitySetting;
+    backgroundColor: ColorWithOpacitySetting;
+}> {
+    constructor(props?: {
+        backgroundImage?: string;
+        opacity?: number;
+        backgroundColor?: string;
+        uploadProps?: UploadSettingProps;
+        collapsed?: boolean;
+    });
+    draw(): HTMLElement;
+    getCssCode(): string;
+}

package/dist/groups/borderSettingsSet.d.ts

@@ -0,0 +1,24 @@
+import { SettingGroup } from '../base/settings-group/settingsGroup';
+import { ColorWithOpacitySetting } from '../settings/color-with-opacity-settings/colorWithOpacitySettings';
+import { NumberSetting } from '../settings/number-settings/numberSettings';
+/**
+ * A SettingGroup for configuring "Border" settings.
+ * It includes child settings for color, opacity, radius, and size.
+ * You can pass default values to override the internal defaults.
+ */
+export declare class BorderSettingSet extends SettingGroup<{
+    color: ColorWithOpacitySetting;
+    radius: NumberSetting;
+    size: NumberSetting;
+}> {
+    constructor(defaults?: {
+        color?: string;
+        radius?: number;
+        size?: number;
+        collapsed?: boolean;
+    });
+    /**
+     * Optional helper to generate CSS from the current settings.
+     */
+    getCssCode(): string;
+}

package/dist/groups/headerTypographySettingsSet.d.ts

@@ -0,0 +1,34 @@
+import { SettingGroup } from '../base/settings-group/settingsGroup';
+import { AlignSetting, AlignValue } from '../settings/align-settings/alignSettings';
+import { ColorWithOpacitySetting } from '../settings/color-with-opacity-settings/colorWithOpacitySettings';
+import { NumberSetting } from '../settings/number-settings/numberSettings';
+import { SelectOption, SelectSetting } from '../settings/select-settings/selectSettings';
+export interface HeaderTypographySettings {
+    title?: string;
+    colorDefault?: string;
+    showAlign?: boolean;
+    colorOpacityDefault?: number;
+    fontFamilyDefault?: string;
+    fontFamilyOptions?: SelectOption[];
+    fontFamilyGetOptions?: () => SelectOption[];
+    fontFamilyGetOptionsAsync?: () => Promise<SelectOption[]>;
+    fontWeightDefault?: string;
+    fontWeightOptions?: SelectOption[];
+    fontWeightGetOptions?: () => SelectOption[];
+    fontWeightGetOptionsAsync?: () => Promise<SelectOption[]>;
+    fontSizeDefault?: number;
+    alignDefault?: AlignValue;
+    collapsed?: boolean;
+    hideCondition?: () => boolean;
+    fontSizeMobileDefault?: number;
+}
+export declare class HeaderTypographySettingSet extends SettingGroup<{
+    color: ColorWithOpacitySetting;
+    fontFamily: SelectSetting<string>;
+    fontWeight: SelectSetting<string>;
+    fontSize: NumberSetting;
+    align?: AlignSetting;
+}> {
+    constructor(props?: HeaderTypographySettings);
+    getCssCode(): string;
+}

package/dist/groups/margin-setting-group/marginSettingGroup.d.ts

@@ -0,0 +1,17 @@
+import { SettingGroup } from '../../base/settings-group/settingsGroup';
+import { MarginNumberSetting } from './marginSettings';
+export declare class MarginSettingGroup extends SettingGroup<{
+    marginTop: MarginNumberSetting;
+    marginRight: MarginNumberSetting;
+    marginBottom: MarginNumberSetting;
+    marginLeft: MarginNumberSetting;
+}> {
+    constructor(defaults?: {
+        marginTop?: number | "auto";
+        marginRight?: number | "auto";
+        marginBottom?: number | "auto";
+        marginLeft?: number | "auto";
+        collapsed?: boolean;
+    });
+    getCssCode(): string;
+}

package/dist/groups/margin-setting-group/marginSettings.d.ts

@@ -0,0 +1,16 @@
+import { InputTypes, Setting, SettingProps } from '../../base/settings';
+import { NumberSuffix } from '../../settings/number-settings/numberSettings';
+export interface MarginNumberSettingsProps extends SettingProps<number | 'auto'> {
+    minValue?: number;
+    maxValue?: number;
+    className?: string;
+    inputClassName?: string;
+    wrapperClassName?: string;
+    suffix?: NumberSuffix;
+    default: number | 'auto';
+}
+export declare class MarginNumberSetting extends Setting<number | 'auto' | undefined, MarginNumberSettingsProps> {
+    inputType: InputTypes;
+    constructor(props: MarginNumberSettingsProps);
+    draw(): HTMLElement;
+}