@golemui/gui-shared 1.1.0 → 1.1.1-rc.1

package/lib/dx/core/defineShortcutType.d.ts

@@ -1,38 +0,0 @@
-import { NonFunctionWidget, FormWidget } from '@golemui/core';
-import { GslLeafSelector, MergeResult } from './dx.domain';
-import { GslConfigBase } from './dxUtilityTypes';
-import { AfterMergeContext, BuildWidgetContext } from './itemTypeRegistry';
-import { DxCommonFields } from './dxBase.types';
-type EntryShape = 'bare' | 'keyed' | 'compound';
-interface SensibleDefaultsSpec<TDecorator, TConfig> {
-    base: TConfig;
-    fields: (keyof TConfig)[];
-    apply: (def: TDecorator, config: TConfig) => TDecorator;
-}
-interface ShortcutTypeConfig<TEntry, TDecorator, TConfig> {
-    itemType: string;
-    entryShape: EntryShape;
-    mapToWidget: (def: TDecorator) => NonFunctionWidget;
-    sensibleDefaults?: SensibleDefaultsSpec<TDecorator, TConfig>;
-    afterMerge?: (mergeResult: MergeResult, context: AfterMergeContext) => MergeResult;
-    buildCustomWidget?: (mergeResult: MergeResult, context: BuildWidgetContext) => FormWidget;
-    getChildren?: (entry: TEntry) => any[] | undefined;
-}
-export interface ShortcutTypeSelectors<TDecorator, TConfig extends GslConfigBase<TDecorator>> {
-    gsl: (config: TConfig, matcher?: (decorator: TDecorator) => boolean) => GslLeafSelector;
-    gslByUid: (uid: string, config: TConfig) => GslLeafSelector;
-}
-/**
- * Convenience factory for registering a new widget type into the DX pipeline.
- *
- * Accepts a simple config object (entry shape, mapToWidget, optional hooks) and
- * assembles a full {@link ItemTypeHandler} from it — generating `parseEntry`,
- * `rollUpSensibleDefaults`, and `applySensibleDefaults` automatically.
- * The handler is registered in the global registry so the pipeline can look it up
- * by `itemType` at runtime.
- *
- * Returns GSL selector factories (`gsl`, `gslByUid`) for styling/configuring
- * widgets of this type.
- */
-export declare function defineShortcutType<TEntry, TDecorator extends DxCommonFields, TConfig extends GslConfigBase<TDecorator> = GslConfigBase<TDecorator>>(config: ShortcutTypeConfig<TEntry, TDecorator, TConfig>): ShortcutTypeSelectors<TDecorator, TConfig>;
-export {};

package/lib/dx/core/dx.domain.d.ts

@@ -1,79 +0,0 @@
-import { ExpressionFunctions, FunctionWidgetParams, ValidateOn } from '@golemui/core';
-import { WidgetItemDecorator, GslItemType } from '../formDef.domain';
-import { Dependencies } from '../../shared';
-export type { GslItemType } from '../formDef.domain';
-export type RuntimeFunction = (params: FunctionWidgetParams<any>) => any;
-export type GuiItemType = string;
-export declare const GuiItemTypes: {
-    readonly INPUTS: "INPUTS";
-    readonly ACTIONS: "ACTIONS";
-    readonly LAYOUTS: "LAYOUTS";
-    readonly DISPLAYS: "DISPLAYS";
-    readonly CUSTOM_DISPLAY: "CUSTOM_DISPLAY";
-    readonly CUSTOM_INPUT: "CUSTOM_INPUT";
-    readonly CUSTOM_ACTION: "CUSTOM_ACTION";
-    readonly CUSTOM_LAYOUT: "CUSTOM_LAYOUT";
-};
-export interface GuiItemsShortcut {
-    type: 'ITEMS';
-    itemType: GuiItemType;
-    items: unknown[];
-    tags: string[];
-}
-export type ValidGuiShortcut = GuiItemsShortcut;
-export type GslMatcher = (decorator: WidgetItemDecorator) => boolean;
-export type GslLeafConfig = Record<string, any>;
-export interface GslLeafSelector {
-    kind: 'leaf';
-    selectorType: GslItemType;
-    matcher: (decorator: any) => boolean;
-    config: GslLeafConfig;
-    /** When set by `_gslStates`, config is applied as state-suffixed overrides. */
-    targetState?: string;
-}
-export interface FormConfig {
-    suppressAutomaticStack?: boolean;
-    dependencies?: Dependencies;
-    /**
-     * Pure functions callable from reactive expressions under the `$fn` namespace.
-     * Functions passed in the wrapper's `config.functions` win on name collisions.
-     */
-    functions?: ExpressionFunctions;
-    widgetLoaders?: Record<string, () => Promise<unknown>>;
-    validateOn?: ValidateOn;
-    states?: Record<string, string>;
-    /**
-     * Framework-specific item renderers (e.g. ReactItemRenderer / AngularItemRenderer / LitItemRenderer).
-     * Forwarded to the unified <gui-form>; the type is intentionally framework-agnostic
-     * here and gets narrowed at the framework wrapper boundary.
-     */
-    itemRenderers?: Record<string, unknown>;
-}
-/**
- * Public-facing form config type for `processDxFacade`'s third argument.
- * Generic over state keys — TypeScript enforces that every declared state name
- * has a corresponding expression.
- *
- * Usage: `processDxFacade<typeof states[number], FormData>(defs, selectors, formConfig)`
- */
-export type DxFormConfig<S extends string = string> = Omit<FormConfig, 'states'> & {
-    states?: Record<S, string>;
-};
-export interface GslAggregatedSelector {
-    kind: 'aggregated';
-    matcher: GslMatcher;
-    children: GslLeafSelector[];
-}
-export type GslSelector = GslAggregatedSelector | GslLeafSelector;
-export type GslSelectorsInput = GslSelector | GslSelector[];
-export interface ResolvedSelectors {
-    leafSelectors: GslLeafSelector[];
-    sensibleDefaults: Record<string, Record<string, any>>;
-}
-export type MergeResult = {
-    kind: 'static';
-    def: Record<string, any>;
-} | {
-    kind: 'dynamic';
-    fn: RuntimeFunction;
-};

package/lib/dx/core/dxBase.types.d.ts

@@ -1,128 +0,0 @@
-import { ActionWidget, FormEvent, Localizable, ReactiveExpression } from '@golemui/core';
-/**
- * DX-enriched FormEvent. Extends the core FormEvent with `update()` — the
- * recommended way for DX event handlers to push widget property changes.
- *
- * `update({ path: 'widget', options: [...] })` translates to OVERRIDE_WIDGET_PROP
- * dispatches under the hood. `callback` is also available for raw/backward-compat use.
- */
-export type DxFormEvent = FormEvent & {
-    update: (arg: {
-        path: string;
-        [prop: string]: any;
-    }) => void;
-};
-/**
- * Event handler type for DX event properties.
- *
- * Function-only, mirroring action `onClick`. Bare strings are NOT accepted — a stray
- * `onChange: 'something'` is a footgun (it looks like a value, not a handler), so the
- * type rejects it.
- *
- * - Return a string to wire a host-managed event name (e.g. `onChange: () => 'fieldChange'`
- *   dispatches `fieldChange` to the host event bus). Only zero-arg handlers are probed for
- *   this, so the `event` parameter is never touched at build time.
- * - Otherwise the handler runs on dispatch; use `event.update(...)` to push widget changes.
- *
- * @example
- * // Host-managed dispatch by name:
- * onChange: () => 'fieldChange'
- * @example
- * // Imperative handler:
- * onChange: (event) => event.update({ path: 'country', options: [] })
- */
-export type DxEventHandler = (event: DxFormEvent) => void | string;
-/**
- * INTERNAL decorator fields — used by the pipeline, NOT by form authors.
- * Contains fields that the pipeline needs but users should never set.
- */
-export interface DxInternalFields {
-    itemType?: string;
-    removeField?: boolean;
-    /**
-     * Sub-type discriminator on the decorator (e.g. `'text' | 'number' | 'boolean'`
-     * for inputs that share the `INPUTS` itemType, `'password'`, `'dropdown'`, etc.
-     * for top-level itemTypes). Carried into the matching phase so sub-type
-     * matchers like `_gslTextInputs((d) => d.type === 'text')` work.
-     */
-    type?: string;
-}
-/**
- * Conditional inclusion: state-list or reactive expression form.
- * Mirrors core's `include` shape on `BaseWidget`.
- */
-export type DxIncludeCondition = {
-    in: string[];
-} | {
-    when: ReactiveExpression;
-};
-/**
- * Conditional exclusion: state-list or reactive expression form.
- * Mirrors core's `exclude` shape on `BaseWidget`.
- */
-export type DxExcludeCondition = {
-    from: string[];
-} | {
-    when: ReactiveExpression;
-};
-/**
- * User-settable common fields available on ALL decorator types.
- */
-export interface DxCommonFields {
-    uid?: string;
-    tags?: string[];
-    size?: number;
-    /**
-     * Per-state property overrides. Keys are state names (use `:` for hierarchy).
-     *
-     * NOTE: the override values are an untyped escape hatch (`Record<string, any>`), so they
-     * are NOT type-checked — e.g. `states: { editing: { onChange: 'foo' } }` compiles even
-     * though a top-level `onChange: 'foo'` does not (events are function-only).
-     */
-    states?: Record<string, Record<string, any>>;
-    /** Conditionally include the widget — by active state list or reactive expression. */
-    include?: DxIncludeCondition;
-    /** Conditionally exclude the widget — by active state list or reactive expression. */
-    exclude?: DxExcludeCondition;
-}
-/**
- * PUBLIC base for input-like decorators.
- * Clean projection of InputWidget properties — no generics, no SomeSuffixable.
- */
-export interface DxInputBase {
-    path?: string;
-    label?: Localizable | null;
-    disabled?: boolean | {
-        when: ReactiveExpression;
-    };
-    readonly?: boolean | {
-        when: ReactiveExpression;
-    };
-    defaultValue?: unknown;
-    onLoad?: DxEventHandler;
-    onChange?: DxEventHandler;
-    onFilter?: DxEventHandler;
-    onBlur?: DxEventHandler;
-}
-/**
- * PUBLIC base for action decorators.
- */
-export interface DxActionBase {
-    label?: Localizable;
-    disabled?: boolean | {
-        when: ReactiveExpression;
-    };
-    actionType?: ActionWidget['actionType'];
-}
-/**
- * PUBLIC base for layout decorators.
- */
-export interface DxLayoutBase {
-    onChange?: DxEventHandler;
-}
-/**
- * PUBLIC base for display decorators.
- * Displays are render-function-only — no shared properties beyond uid.
- */
-export interface DxDisplayBase {
-}

package/lib/dx/core/dxPropsHelper.d.ts

@@ -1,9 +0,0 @@
-import { DxCommonFields, DxInputBase } from './dxBase.types';
-type DxBaseKeys = keyof DxInputBase | keyof DxCommonFields | 'type';
-/**
- * Extract widget-specific props from a flattened decorator.
- * Strips DxInputBase + DxCommonFields fields, event properties,
- * and pipeline-internal `on` from the output.
- */
-export declare function extractWidgetProps<D extends DxInputBase & DxCommonFields>(def: D): Omit<D, DxBaseKeys>;
-export {};

package/lib/dx/core/dxUtilityTypes.d.ts

@@ -1,40 +0,0 @@
-import { FunctionWidgetParams } from '@golemui/core';
-import { RuntimeFunction, GuiItemsShortcut, GslLeafSelector } from './dx.domain';
-export type DxRuntimeParams<FormData = any> = FunctionWidgetParams<FormData>;
-/**
- * Generic GSL decorator callback — same structure for every type.
- * Usage: replace per-type `GslCalendarDecoratorCallback`, `GslInputDecoratorCallback`, etc.
- */
-export type GslDecoratorCallback<D> = (current: D) => Partial<D> | RuntimeFunction;
-/**
- * A field definition can be a static decorator or a runtime callback.
- * Usage: replace per-type `CalendarDefOrCallback`, `ActionDefOrCallback`, etc.
- */
-export type DefOrCallback<D, TForm = any> = D | ((params: DxRuntimeParams<TForm>) => Partial<D>);
-/**
- * Standard GSL config shape — override + optional suppress flags.
- * Extend this for types that have additional GSL config fields.
- * Usage: replace per-type `GslCalendarConfig`, `GslInputConfig`, etc. base shape.
- */
-export interface GslConfigBase<D> {
-    override?: Partial<D> | GslDecoratorCallback<D>;
-}
-/**
- * Typed GUI shortcut sub-interface.
- * Usage: replace per-type `GuiCalendarShortcut`, `GuiInputsShortcut`, etc.
- */
-export interface GuiShortcutOf<TItemType extends string, TEntry> extends GuiItemsShortcut {
-    itemType: TItemType;
-    items: TEntry[];
-}
-/**
- * Creates a GSL selector factory for a given shortcut type.
- * Eliminates the need for per-type gsl*.impl.ts files.
- *
- * @example
- * ```ts
- * export const _gslCalendars = createGslSelector<CalendarDecorator, GslCalendarConfig>('CALENDAR');
- * // Equivalent to the hand-written gslCalendar.impl.ts factory
- * ```
- */
-export declare function createGslSelector<D, TConfig extends GslConfigBase<D> = GslConfigBase<D>>(selectorType: string): (config: TConfig, matcher?: (decorator: D) => boolean) => GslLeafSelector;

package/lib/dx/core/dxValidatorHelper.d.ts

@@ -1,31 +0,0 @@
-import { CustomValidator, Validator } from '@golemui/gui-validators';
-type ValidatorFn = (api: any) => Partial<Validator>;
-/**
- * Validator shape accepted by a DX widget whose value type is fixed (e.g.
- * a `textInput`'s value is always a string). The user may either:
- *   - omit the `type` discriminator and write only the rules for that fixed
- *     kind (`{ minLength: 5 }`), which `buildTypedValidator` will tag with the
- *     correct `type` at form-def construction time, or
- *   - opt out and supply a fully-typed `CustomValidator`
- *     (`{ type: 'custom', <validatorName>: <config> }`), which the engine
- *     resolves against `customValidators` at validation time.
- *
- * The two branches are discriminated by the presence of `type: 'custom'`.
- */
-export type DxValidator<T extends Validator> = Omit<T, 'type'> | CustomValidator;
-/**
- * Build a fixed-type validator from a user-supplied partial validator and a
- * known JSON-schema type. The DX layer uses this for widgets whose value
- * shape is fixed (e.g. password is always string, currency always number,
- * calendar always string-with-format, repeater always array).
- *
- * Runtime-function validators are passed through unchanged — the function's
- * return value is responsible for setting `type` itself. The function is
- * evaluated by the engine on every form-data change.
- *
- * When `validator` is `undefined`, returns a no-op typed validator
- * (`{ type }` with no rules). Callers can still gate the call with a null
- * check when they only want to emit `validator` if the user supplied one.
- */
-export declare function buildTypedValidator(validator: Record<string, unknown> | ValidatorFn | undefined, type: Validator['type']): Validator | ValidatorFn;
-export {};

package/lib/dx/core/eventWiring.service.d.ts

@@ -1,34 +0,0 @@
-import { FormEvent } from '@golemui/core';
-import { MergeResult } from './dx.domain';
-import { EventIdGenerator } from './itemTypeRegistry';
-export type EventRegistry = Map<string, (event: FormEvent) => void>;
-/**
- * Probe a DX event handler for a host-managed event name.
- *
- * Mirrors the action `onClick` pattern: a handler that simply returns a string
- * (`() => 'fieldChange'`) declares a host-managed dispatch by name. Only **zero-arg**
- * handlers are probed — a handler that declares the `event` parameter
- * (`(event) => event.update(...)`) is an imperative handler and is never invoked here,
- * so its method-bearing `DxFormEvent` is never touched with `undefined`.
- *
- * @returns the returned event name, or `null` when the handler is not a declarative
- *   zero-arg string-returning handler (i.e. it should be registered and run on dispatch).
- */
-export declare function probeForHostEventName(handler: (...args: any[]) => any): string | null;
-/**
- * Generalisation of ActionOnClickService.
- *
- * Two entry points:
- * - `extractOnClickFromMergeResult` — action-specific: handles onClick wiring.
- *   Called from the actions afterMerge hook.
- * - `wireInputLayoutEvents` — universal: handles onLoad, onChange, onFilter on any widget.
- *   Called from ItemWalker.processItem for every item.
- */
-export declare class EventWiringService {
-    extractOnClickFromMergeResult(mergeResult: MergeResult, eventRegistry: EventRegistry, eventIdGenerator: EventIdGenerator): MergeResult;
-    private wireOnClick;
-    wireInputLayoutEvents(mergeResult: MergeResult, eventRegistry: EventRegistry, eventIdGenerator: EventIdGenerator): MergeResult;
-    private wireEventProperties;
-}
-declare const eventWiringService: EventWiringService;
-export default eventWiringService;

package/lib/dx/core/itemTypeRegistry.d.ts

@@ -1,82 +0,0 @@
-import { FormWidget, NonFunctionWidget, UiState, FormEvent } from '@golemui/core';
-import { DxRuntimeParams } from './dxUtilityTypes';
-import { GslLeafSelector, FormConfig, MergeResult, ValidGuiShortcut, GslItemType } from './dx.domain';
-import { DxCommonFields } from './dxBase.types';
-export interface ParsedEntry<TDecorator extends DxCommonFields = DxCommonFields> {
-    baseDef: TDecorator | ((params: DxRuntimeParams) => Partial<TDecorator>);
-    path?: string;
-    children?: ValidGuiShortcut[];
-}
-export type EventRegistry = Map<string, (event: FormEvent) => void>;
-export interface EventIdGenerator {
-    next(): string;
-}
-export interface AfterMergeContext {
-    eventRegistry: EventRegistry;
-    formConfig: FormConfig;
-    eventIdGenerator: EventIdGenerator;
-}
-export interface BuildWidgetContext {
-    children?: ValidGuiShortcut[];
-    mapStaticDef: (def: Record<string, any>, itemType: GslItemType) => NonFunctionWidget;
-    walkChildren: (children: ValidGuiShortcut[]) => FormWidget[];
-}
-/**
- * Strategy interface for a widget type (inputs, actions, layouts, calendars, etc.).
- *
- * The DX pipeline (`ItemWalker.processItem`) is generic — it walks the widget tree,
- * resolves selectors, merges definitions, and maps to framework widgets. But each
- * widget type has its own entry shape, its own sensible defaults, and sometimes
- * custom post-merge or widget-building logic. The handler provides these type-specific
- * behaviors at well-defined extension points in the pipeline:
- *
- *   1. `parseEntry`             — parse raw entry into a normalized `ParsedEntry`
- *   2. `rollUpSensibleDefaults` — aggregate config from matching leaf selectors
- *   3. `applySensibleDefaults`  — apply aggregated config to a merged decorator
- *   4. `mapToWidget`            — map a decorator to a core `FormWidget`
- *   5. `afterMerge` (optional)  — post-merge hook (e.g. actions use this to wire onClick)
- *   6. `buildCustomWidget` (optional) — custom widget building for compound types (e.g. layouts
- *                                  that need to recursively walk children)
- *
- * Shortcut authors do NOT implement this interface directly. Instead, they call
- * {@link defineShortcutType} with a simple config object, and it assembles the full
- * handler and registers it in the global registry.
- *
- * Entry shape taxonomy:
- *
- * 1. Keyed entries — { key, def } — path derived from key
- *    Used by: inputs, future select/radiogroup
- *
- * 2. Bare entries — decorator | callback directly
- *    Used by: actions, calendar, displays
- *
- * 3. Compound entries — { def, children } — container with nested shortcuts
- *    Used by: layouts, future tabs/accordion
- *
- * Each handler declares TEntry to match its shape.
- * There is no shared base type — the shapes are intentionally different.
- * parseEntry(entry: TEntry) is the type-safe boundary.
- */
-export interface ItemTypeHandler<TEntry = any, TDecorator extends DxCommonFields = DxCommonFields, TConfig = Record<string, any>> {
-    rollUpSensibleDefaults(leafSelectors: GslLeafSelector[]): TConfig;
-    applySensibleDefaults(def: TDecorator, config: TConfig): TDecorator;
-    mapToWidget<StateKeys extends UiState = never, FormData extends Record<string, any> = any>(def: TDecorator): NonFunctionWidget<StateKeys, FormData>;
-    parseEntry(entry: TEntry): ParsedEntry<TDecorator>;
-    afterMerge?(mergeResult: MergeResult, context: AfterMergeContext): MergeResult;
-    /**
-     * Optional override for widget types that need custom construction beyond the
-     * generic mapToWidget path. Two flavors:
-     *
-     * - Compound types (layouts, accordion, tabs, repeater): use `context.walkChildren`
-     *   to recursively process child widgets and attach them to the result.
-     * - Custom rendering (displays): wrap a render function into a specialized widget
-     *   shape that the generic mapper can't produce.
-     *
-     * If not provided, the pipeline falls back to `mapToWidget` for simple leaf types.
-     */
-    buildCustomWidget?(mergeResult: MergeResult, context: BuildWidgetContext): FormWidget;
-    getChildren?(entry: TEntry): ValidGuiShortcut[] | undefined;
-}
-export declare function registerItemType(itemType: string, handler: ItemTypeHandler<any, any, any>): void;
-export declare function getItemTypeHandler(itemType: string): ItemTypeHandler<any, any, any>;
-export declare function hasItemTypeHandler(itemType: string): boolean;

package/lib/dx/core/itemWalker.service.d.ts

@@ -1,31 +0,0 @@
-import { FormWidget, UiState } from '@golemui/core';
-import { FormConfig, GslSelector, ValidGuiShortcut } from './dx.domain';
-import { SelectorResolver } from './selectorResolver.service';
-import { WidgetMerger } from './widgetMerger.service';
-import { WidgetMapper } from './widgetMapper.service';
-import { EventRegistry } from './itemTypeRegistry';
-import { EventWiringService } from './eventWiring.service';
-import { StateExpansionService } from './stateExpansion.service';
-export interface WalkResult<StateKeys extends UiState = never, FormData extends Record<string, any> = any> {
-    widgets: FormWidget<StateKeys, FormData>[];
-    eventRegistry: EventRegistry;
-}
-export declare class ItemWalker {
-    private readonly resolver;
-    private readonly merger;
-    private readonly mapper;
-    private readonly eventWiring;
-    private readonly stateExpansion;
-    constructor(resolver: SelectorResolver, merger: WidgetMerger, mapper: WidgetMapper, eventWiring: EventWiringService, stateExpansion: StateExpansionService);
-    walkAndMap<StateKeys extends UiState = never, FormData extends Record<string, any> = any>(guiShortcuts: ValidGuiShortcut[], gslSelectors: GslSelector[], formConfig: FormConfig): WalkResult<StateKeys, FormData>;
-    private walkItems;
-    private processItem;
-    private buildCustomWidgetContext;
-    private buildCustomWidget;
-    /**
-     * Resolves the base definition from a parsed entry, injecting the path for keyed entries.
-     * For runtime (function) providers, wraps them to inject the path at evaluation time.
-     */
-    private buildBaseDef;
-    private buildDecoratorForMatching;
-}

package/lib/dx/core/selectorNormalizer.service.d.ts

@@ -1,15 +0,0 @@
-import { FormConfig, GslSelector, GslSelectorsInput } from './dx.domain';
-export declare class SelectorNormalizer {
-    /**
-     * Ensures the output is always a uniform GslSelector[] of aggregated selectors.
-     *
-     * Callers can pass flat leaf selectors (single styling rules) or pre-grouped
-     * aggregated selectors. This method separates them into two buckets, then wraps
-     * any bare leaves into a catch-all aggregated selector so downstream code only
-     * deals with one shape.
-     */
-    normalizeSelectors(input: GslSelectorsInput): GslSelector[];
-    extractFormConfig(): FormConfig;
-}
-declare const selectorNormalizer: SelectorNormalizer;
-export default selectorNormalizer;

package/lib/dx/core/selectorResolver.service.d.ts

@@ -1,11 +0,0 @@
-import { GslSelector, ResolvedSelectors } from './dx.domain';
-import { DxCommonFields, DxInternalFields } from './dxBase.types';
-type DecoratorForMatching = DxInternalFields & DxCommonFields;
-export declare class SelectorResolver {
-    resolve(decorator: DecoratorForMatching, allSelectors: GslSelector[]): ResolvedSelectors;
-    private collectFromAggregated;
-    private collectFromLeaf;
-    private rollUpSensibleDefaults;
-}
-declare const selectorResolver: SelectorResolver;
-export default selectorResolver;

package/lib/dx/core/sharedSensibleDefaults.service.d.ts

@@ -1,35 +0,0 @@
-import { Localizable } from '@golemui/core';
-/**
- * Config interface for types that support automatic labels.
- */
-export interface LabelSensibleDefaultsConfig {
-    suppressAutomaticLabels?: boolean;
-}
-/**
- * Config interface for types that support automatic placeholders.
- */
-export interface PlaceholderSensibleDefaultsConfig {
-    suppressAutomaticPlaceholders?: boolean;
-}
-export declare function pathToLabel(path: string | undefined): string;
-/**
- * Auto-generate a label from the field path if none is explicitly set.
- * Reusable across inputs, calendar, and future input-like types.
- *
- * Behavior must match existing `inputSensibleDefaults.service.ts` and
- * `calendarSensibleDefaults.service.ts` exactly.
- */
-export declare function processAutoLabel<D extends {
-    path?: string;
-    label?: Localizable | null;
-}>(def: D, config: LabelSensibleDefaultsConfig): D;
-/**
- * Auto-generate a placeholder from the field path if none is explicitly set.
- * Reusable across inputs, textarea, password, and future input-like types.
- *
- * Behavior must match existing `inputSensibleDefaults.service.ts` exactly.
- */
-export declare function processAutoPlaceholder<D extends {
-    path?: string;
-    placeholder?: string;
-}>(def: D, config: PlaceholderSensibleDefaultsConfig): D;

package/lib/dx/core/stateExpansion.service.d.ts

@@ -1,31 +0,0 @@
-import { NonFunctionWidget } from '@golemui/core';
-import { GslLeafSelector, MergeResult } from './dx.domain';
-import { EventIdGenerator, EventRegistry } from './itemTypeRegistry';
-export interface StateData {
-    stateOverrides: Record<string, Record<string, any>>;
-}
-export declare class StateExpansionService {
-    /**
-     * Extracts `states` from a merge result, combining with state-targeted
-     * GSL leaf selectors from `_gslStates`.
-     *
-     * Returns a cleaned merge result (no states) and accumulated state data.
-     */
-    extractFromMergeResult(mergeResult: MergeResult, stateLeafs: GslLeafSelector[]): {
-        cleanedResult: MergeResult;
-        stateData: StateData;
-    };
-    /**
-     * Applies state overrides to a core widget. Each override produces:
-     * - `visible: true/false` → `include: { in }` / `exclude: { from }`
-     * - Core suffixable props → `'prop.stateName': value` at widget root
-     * - Event handlers → `on: { 'eventType.stateName': eventId }` with registry wiring
-     * - Custom props → `props: { 'prop.stateName': value }`
-     */
-    applyToWidget(widget: NonFunctionWidget, stateData: StateData, eventRegistry: EventRegistry, eventIdGenerator: EventIdGenerator): NonFunctionWidget;
-    hasStateData(stateData: StateData): boolean;
-    private applyVisibility;
-    private applyStateEvent;
-}
-declare const stateExpansionService: StateExpansionService;
-export default stateExpansionService;

package/lib/dx/core/widgetMapper.service.d.ts

@@ -1,13 +0,0 @@
-import { FormWidget, NonFunctionWidget, UiState } from '@golemui/core';
-import { GslItemType, MergeResult } from './dx.domain';
-export declare class WidgetMapper {
-    mapToWidget<StateKeys extends UiState = never, FormData extends Record<string, any> = any>(mergeResult: MergeResult, itemType: GslItemType): FormWidget<StateKeys, FormData>;
-    mapStaticDef<StateKeys extends UiState = never, FormData extends Record<string, any> = any>(def: Record<string, any>, itemType: GslItemType): NonFunctionWidget<StateKeys, FormData>;
-    /**
-     * Injects BaseWidget-level fields that all widget types share.
-     * Centralized here so individual mappers don't need to repeat the pattern.
-     */
-    private applyBaseWidgetFields;
-}
-declare const widgetMapper: WidgetMapper;
-export default widgetMapper;

package/lib/dx/core/widgetMerger.service.d.ts

@@ -1,14 +0,0 @@
-import { GslItemType, MergeResult, ResolvedSelectors, RuntimeFunction } from './dx.domain';
-import { ObjectUtils } from '../../utils/objectUtils.service';
-export declare class WidgetMerger {
-    private readonly objectUtils;
-    constructor(objectUtils: ObjectUtils);
-    merge(baseDef: Record<string, any> | RuntimeFunction, itemType: GslItemType, resolved: ResolvedSelectors): MergeResult;
-    private collectDecorators;
-    private applySensibleDefaults;
-    private createPromotedFunction;
-    private wrapWithSensibleDefaults;
-    private composeRuntimeFunctions;
-}
-declare const widgetMerger: WidgetMerger;
-export default widgetMerger;

package/lib/dx/core/withForm.d.ts

@@ -1,8 +0,0 @@
-import { FunctionWidgetParams } from '@golemui/core';
-/**
- * Runtime functions can run during the build walk / decode probe before form
- * data exists; the FunctionWidgetParams contract guarantees `$form` is an
- * object, so normalize it to at least `{}` — a callback reading
- * `params.$form.field` must get `undefined`, not crash.
- */
-export declare function withForm(params?: FunctionWidgetParams<any>): FunctionWidgetParams<any>;

package/lib/dx/dx.service.d.ts

@@ -1,36 +0,0 @@
-import { UiState } from '@golemui/core';
-import { DxDefinitions, DxResult } from './formDef.domain';
-import { DxFormConfig, GslSelectorsInput } from './core/dx.domain';
-import { SelectorNormalizer } from './core/selectorNormalizer.service';
-import { ItemWalker } from './core/itemWalker.service';
-/**
- * Transforms a developer-friendly form definition into a fully-fledged form definition
- * usable by the framework ({@link Form}<STATE_KEYS, FORM_DATA>).
- *
- * Orchestrates: prepareForm → walkAndMap → buildResult.
- */
-export declare class DxService {
-    private readonly selectorNormalizer;
-    private readonly walker;
-    constructor(selectorNormalizer: SelectorNormalizer, walker: ItemWalker);
-    processDxFacade<STATE_KEYS extends UiState = never, FORM_DATA extends Record<string, any> = any>(dxDefinitionsRaw: DxDefinitions, gslSelectorsInput?: GslSelectorsInput, formConfigInput?: DxFormConfig<STATE_KEYS>): DxResult<STATE_KEYS, FORM_DATA>;
-    /**
-     * Normalizes raw form definitions and applies form-level defaults.
-     *
-     * Steps:
-     *  1. Normalize definitions — ensure a flat array; convert bare functions to display widgets.
-     *  2. Normalize selectors — convert mixed leaf/aggregated selectors into a uniform
-     *     aggregated shape, and extract form-level config (see {@link FormConfig}).
-     *  3. Auto-stack — unless suppressed, wrap all definitions in a synthetic root
-     *     flex column layout so the form renders as a single vertical container.
-     */
-    private prepareForm;
-    /**
-     * Converts DX `$`-separated state names to core's `:`-separated names.
-     * E.g. `{ register$adult: 'expr' }` → `{ 'register:adult': 'expr' }`.
-     */
-    private convertStateNames;
-    private buildResult;
-}
-declare const formDefs: DxService;
-export { formDefs };