@infotrust/ui 0.0.0-stage → 0.30.0

package/dist/components/logic/ItFieldPicker.vue.d.ts

@@ -0,0 +1,40 @@
+import { type ItLogicField } from './logic';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: string | null;
+    fields?: readonly ItLogicField[];
+    /** Field keys picked recently, newest first. Shown in a "Recent" group. */
+    recent?: readonly string[];
+    /** Accessible name. */
+    label?: string;
+    placeholder?: string;
+    size?: "sm" | "md";
+    disabled?: boolean;
+    invalid?: boolean;
+    describedBy?: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (key: string | null) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue: string | null;
+    fields?: readonly ItLogicField[];
+    /** Field keys picked recently, newest first. Shown in a "Recent" group. */
+    recent?: readonly string[];
+    /** Accessible name. */
+    label?: string;
+    placeholder?: string;
+    size?: "sm" | "md";
+    disabled?: boolean;
+    invalid?: boolean;
+    describedBy?: string;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((key: string | null) => any) | undefined;
+}>, {
+    label: string;
+    invalid: boolean;
+    disabled: boolean;
+    size: "sm" | "md";
+    placeholder: string;
+    describedBy: string;
+    fields: readonly ItLogicField[];
+    recent: readonly string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/logic/ItLogicBuilder.vue.d.ts

@@ -0,0 +1,58 @@
+import { type ItLogicContext, type ItLogicField, type ItLogicGroup as ItLogicGroupModel, type ItLogicIssue, type ItLogicJoinChoice, type ItLogicGroupScope, type ItLogicOperator, type ItLogicRowScope, type ItLogicValueScope } from './logic';
+type __VLS_Props = {
+    modelValue: ItLogicGroupModel;
+    fields: readonly ItLogicField[];
+    /** Extra or replacement operators; a default with the same key is replaced in place. */
+    operators?: readonly ItLogicOperator[];
+    /** Group levels allowed below the root. 0 = conditions only. */
+    maxDepth?: number;
+    /** Join choices group headers offer. `none` = none of the following (NOT). */
+    joins?: readonly ItLogicJoinChoice[];
+    /** First word of the root header: "Match", "One push must match". */
+    lead?: string;
+    /** Field keys picked recently, newest first, for the picker's "Recent" group. */
+    recentFields?: readonly string[];
+    /** Show every issue now, inline and as a summary. Set after a submit attempt. */
+    showErrors?: boolean;
+    /** Override validation when the consuming engine has different semantics. */
+    validate?: (root: ItLogicGroupModel, context: ItLogicContext) => ItLogicIssue[];
+    readonly?: boolean;
+    disabled?: boolean;
+};
+type __VLS_Slots = {
+    'row-start'?: (scope: ItLogicRowScope) => unknown;
+    'row-end'?: (scope: ItLogicRowScope) => unknown;
+    'group-head'?: (scope: ItLogicGroupScope) => unknown;
+    'group-foot'?: (scope: ItLogicGroupScope) => unknown;
+    empty?: (scope: ItLogicGroupScope) => unknown;
+    [valueKind: `value-${string}`]: ((scope: ItLogicValueScope) => unknown) | undefined;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    /** Every current issue. */
+    issues: import("vue").ComputedRef<ItLogicIssue[]>;
+    valid: import("vue").ComputedRef<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: ItLogicGroupModel) => any;
+    "update:valid": (valid: boolean) => any;
+    issues: (issues: ItLogicIssue[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: ItLogicGroupModel) => any) | undefined;
+    "onUpdate:valid"?: ((valid: boolean) => any) | undefined;
+    onIssues?: ((issues: ItLogicIssue[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    operators: readonly ItLogicOperator[];
+    readonly: boolean;
+    lead: string;
+    maxDepth: number;
+    joins: readonly ItLogicJoinChoice[];
+    recentFields: readonly string[];
+    showErrors: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/logic/ItLogicCondition.vue.d.ts

@@ -0,0 +1,9 @@
+import { type ItLogicCondition } from './logic';
+type __VLS_Props = {
+    condition: ItLogicCondition;
+    depth: number;
+    index: number;
+    siblings: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/logic/ItLogicGroup.vue.d.ts

@@ -0,0 +1,9 @@
+import { type ItLogicGroup } from './logic';
+type __VLS_Props = {
+    group: ItLogicGroup;
+    depth: number;
+    index: number;
+    siblings: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/logic/ItOperatorSelect.vue.d.ts

@@ -0,0 +1,25 @@
+import { type ItLogicField, type ItLogicOperator } from './logic';
+type __VLS_Props = {
+    modelValue: string | null;
+    field: ItLogicField | undefined;
+    operators?: readonly ItLogicOperator[];
+    /** Accessible name. */
+    label?: string;
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+    invalid?: boolean;
+    describedBy?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (key: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((key: string) => any) | undefined;
+}>, {
+    label: string;
+    invalid: boolean;
+    disabled: boolean;
+    size: "sm" | "md";
+    operators: readonly ItLogicOperator[];
+    describedBy: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/logic/ItValueInput.vue.d.ts

@@ -0,0 +1,29 @@
+import { type ItLogicField, type ItLogicOperator } from './logic';
+type __VLS_Props = {
+    modelValue: unknown;
+    field: ItLogicField | undefined;
+    /** Operator key. */
+    operator: string | null;
+    operators?: readonly ItLogicOperator[];
+    /** Available fields for a field reference. Defaults to the builder's fields. */
+    fields?: readonly ItLogicField[];
+    /** Accessible name; parts of compound editors append "minimum", "unit", … */
+    label?: string;
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+    invalid?: boolean;
+    describedBy?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: unknown) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
+}>, {
+    label: string;
+    invalid: boolean;
+    disabled: boolean;
+    size: "sm" | "md";
+    operators: readonly ItLogicOperator[];
+    describedBy: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/logic/logic.d.ts

@@ -0,0 +1,263 @@
+import type { ComputedRef, InjectionKey, Slots } from 'vue';
+export type ItLogicJoin = 'all' | 'any';
+/** The three choices a group header offers. `none` is `any` + `negate`. */
+export type ItLogicJoinChoice = 'all' | 'any' | 'none';
+/** For fields that hold several values (every tag in a container): which of them must match. */
+export type ItLogicQuantifier = 'every' | 'any' | 'none';
+export interface ItLogicCondition {
+    id: string;
+    /** `ItLogicField.key`, or null until the user picks one. */
+    field: string | null;
+    /** `ItLogicOperator.key`, or null until a field is picked. */
+    operator: string | null;
+    value: unknown;
+    /** Only for fields with `multiple`. Default `every`. */
+    quantifier?: ItLogicQuantifier;
+    /** App-owned data the builder carries untouched (state for row regions). */
+    meta?: Record<string, unknown>;
+}
+export interface ItLogicGroup {
+    id: string;
+    join: ItLogicJoin;
+    /** Negates the whole group. With `join: 'any'` this is "none of the following". */
+    negate?: boolean;
+    children: ItLogicNode[];
+    /** App-owned data the builder carries untouched (state for group regions). */
+    meta?: Record<string, unknown>;
+}
+export type ItLogicNode = ItLogicCondition | ItLogicGroup;
+export type ItLogicFieldType = 'string' | 'number' | 'date' | 'boolean' | 'enum';
+export interface ItLogicOption {
+    value: string | number | boolean;
+    label: string;
+}
+export interface ItLogicField {
+    /** Stable id stored in conditions. */
+    key: string;
+    /** Sentence-case noun phrase: "Container name", "Last published". */
+    label: string;
+    type: ItLogicFieldType;
+    /** Picker group ("Container", "Tags", "Event params"). */
+    category?: string;
+    /** One line shown under the label in the picker. */
+    description?: string;
+    /** Choices for `enum` fields; suggestions for `string` lists. */
+    options?: ItLogicOption[];
+    /** The field holds several values; the row gets an every/any/none quantifier. */
+    multiple?: boolean;
+    /** Listed first in the picker; the builder asks for one condition on it. */
+    required?: boolean;
+    /** Limit the operators offered (keys); default: every operator for the type. */
+    operators?: string[];
+    /** Placeholder for text and number values ("USD"). */
+    placeholder?: string;
+}
+/**
+ * What a value editor edits. `scalar` and `list` resolve per field type:
+ * scalar → text | number | date | boolean | option, list → options (enum) | list.
+ * Any other string is a custom kind, rendered by the builder's `value-<kind>` slot.
+ */
+export type ItLogicValueKind = 'none' | 'scalar' | 'list' | 'text' | 'pattern' | 'number' | 'number-range' | 'date' | 'duration' | 'duration-ago' | 'boolean' | 'option' | 'options' | 'field' | (string & {});
+/** A reference to another field, stored independently of its display label. */
+export interface ItLogicFieldValue {
+    field: string | null;
+}
+export interface ItLogicOperator {
+    key: string;
+    /** Plain words, the same in the row and the summary: "is", "contains", "is more than". */
+    label: string;
+    /** Field types the operator applies to. `'*'` = all. */
+    types: readonly ItLogicFieldType[] | '*';
+    value: ItLogicValueKind;
+    /** Starting value for custom kinds. */
+    defaultValue?: () => unknown;
+    /** Return a message ("Enter a value.") when the value is unusable, else null. Custom kinds only; built-in kinds validate themselves. */
+    validate?: (value: unknown, field: ItLogicField) => string | null;
+    /** Summary words for the value ("Accept all or GPC"). Custom kinds only. Return '' when incomplete. */
+    describe?: (value: unknown, field: ItLogicField) => string;
+}
+export interface ItLogicDuration {
+    amount: number | null;
+    unit: 'minutes' | 'hours' | 'days' | 'months';
+}
+/** The default operator registry, in the order the operator select lists them. */
+export declare const IT_LOGIC_OPERATORS: readonly ItLogicOperator[];
+/** Defaults plus app operators. An app operator with a default's key replaces it in place. */
+export declare function mergeOperators(custom?: readonly ItLogicOperator[]): ItLogicOperator[];
+/** Operators a field offers, in registry order. */
+export declare function operatorsFor(field: ItLogicField | undefined, registry?: readonly ItLogicOperator[]): ItLogicOperator[];
+/** The concrete editor kind for an operator on a field. */
+export declare function resolveValueKind(operator: ItLogicOperator | undefined, field: ItLogicField | undefined): ItLogicValueKind;
+/** The empty value an editor of this kind starts with. */
+export declare function defaultValueFor(kind: ItLogicValueKind, operator?: ItLogicOperator): unknown;
+/** The muted type word the field picker shows next to a field. */
+export declare function fieldTypeLabel(field: ItLogicField): string;
+/** A short id, unique within the page. Apps that persist trees may pass their own ids. */
+export declare function createLogicId(prefix?: string): string;
+export declare function createCondition(init?: Partial<Omit<ItLogicCondition, 'id'>> & {
+    id?: string;
+}): ItLogicCondition;
+export declare function createGroup(init?: Partial<Omit<ItLogicGroup, 'id'>> & {
+    id?: string;
+}): ItLogicGroup;
+export declare function isLogicGroup(node: ItLogicNode | null | undefined): node is ItLogicGroup;
+export declare function joinChoice(group: ItLogicGroup): ItLogicJoinChoice | 'not-all';
+export declare function applyJoinChoice(group: ItLogicGroup, choice: ItLogicJoinChoice | 'not-all'): ItLogicGroup;
+export interface ItLogicLocation {
+    node: ItLogicNode;
+    parent: ItLogicGroup | null;
+    index: number;
+    /** 0 for the root group, 1 for its children, … */
+    depth: number;
+}
+export declare function findNode(root: ItLogicGroup, id: string): ItLogicLocation | null;
+/** Every condition in the tree, depth first. */
+export declare function listConditions(root: ItLogicGroup): ItLogicCondition[];
+/** True when the tree has no conditions at all (empty groups do not count). */
+export declare function isEmpty(root: ItLogicGroup): boolean;
+/** How many group levels sit below `group` (0 for a group of only conditions). */
+export declare function groupHeight(group: ItLogicGroup): number;
+/** Replace the node with `id` by `fn(node)`. Returns the same root when the id is unknown. */
+export declare function updateNode<T extends ItLogicNode>(root: ItLogicGroup, id: string, fn: (node: T) => ItLogicNode): ItLogicGroup;
+/** Remove a node. The root itself cannot be removed. */
+export declare function removeNode(root: ItLogicGroup, id: string): ItLogicGroup;
+/** Insert `node` into the group `groupId` at `index` (default: the end). */
+export declare function insertNode(root: ItLogicGroup, groupId: string, node: ItLogicNode, index?: number): ItLogicGroup;
+/** Move a node up (-1) or down (+1) among its siblings. */
+export declare function moveNode(root: ItLogicGroup, id: string, delta: -1 | 1): ItLogicGroup;
+/** A deep copy with fresh ids. */
+export declare function cloneWithNewIds<T extends ItLogicNode>(node: T): T;
+/** Insert a copy of the node right after it. */
+export declare function duplicateNode(root: ItLogicGroup, id: string): ItLogicGroup;
+/** Replace a node with a new group that contains it. */
+export declare function wrapInGroup(root: ItLogicGroup, id: string, join?: ItLogicJoin): ItLogicGroup;
+/**
+ * Point a condition at a new field. The operator survives when the new field
+ * offers it, and the value survives when it edits the same kind of value
+ * ("is USD" moves from one text field to another; it never becomes a number,
+ * and a choice survives only if the new field has that choice). Otherwise the
+ * condition takes the field's first operator and an empty value.
+ */
+export declare function setConditionField(condition: ItLogicCondition, field: ItLogicField | undefined, context: ItLogicContext): ItLogicCondition;
+/**
+ * Change a condition's operator. The value survives when the new operator
+ * edits the same kind of value; scalar ↔ list converts ("USD" ↔ ["USD"]);
+ * anything else starts empty.
+ */
+export declare function setConditionOperator(condition: ItLogicCondition, operatorKey: string, field: ItLogicField | undefined, registry?: readonly ItLogicOperator[]): ItLogicCondition;
+/** Set an app-owned meta key on a node. */
+export declare function setNodeMeta(root: ItLogicGroup, id: string, patch: Record<string, unknown>): ItLogicGroup;
+/** `empty` = the root has no children; `group` = a nested group has none. */
+export type ItLogicIssueKind = 'field' | 'operator' | 'value' | 'invalid' | 'group' | 'empty' | 'required';
+export interface ItLogicIssue {
+    /** The node the issue belongs to (the root for builder-level issues). */
+    id: string;
+    kind: ItLogicIssueKind;
+    /** What to do, as a sentence: "Enter a value." */
+    message: string;
+}
+export interface ItLogicContext {
+    fields: readonly ItLogicField[];
+    operators?: readonly ItLogicOperator[];
+}
+/** Issues for one condition, most important first. Empty when the condition is complete. */
+export declare function validateCondition(condition: ItLogicCondition, context: ItLogicContext): ItLogicIssue[];
+/** Every issue in the tree: incomplete conditions, empty groups, missing required fields. */
+export declare function validate(root: ItLogicGroup, context: ItLogicContext): ItLogicIssue[];
+/** One sentence for the whole builder: "2 conditions need a value and 1 group is empty." */
+export declare function summarizeIssues(issues: readonly ItLogicIssue[]): string;
+/** A piece of a condition sentence, used by builder rows and descriptions. */
+export interface ItLogicToken {
+    kind: 'field' | 'operator' | 'value' | 'join' | 'text' | 'missing' | 'open' | 'close';
+    text: string;
+}
+export interface ItLogicSummaryOptions {
+    /**
+     * Rewrite one condition's tokens, e.g. to add a row region's state
+     * ("must not fire"). Receives the default tokens; return new ones.
+     */
+    condition?: (condition: ItLogicCondition, tokens: ItLogicToken[]) => ItLogicToken[];
+}
+/** "2026-10-09" → "Oct 9" via the shared formatter, read as a local calendar date. */
+export declare function formatLogicDate(value: unknown): string;
+/** The words for a value, or '' when it is incomplete. */
+export declare function describeValue(kind: ItLogicValueKind, value: unknown, field: ItLogicField, operator?: ItLogicOperator, fields?: readonly ItLogicField[]): string;
+/** Tokens for one condition: field, operator, value (missing parts as muted prompts). */
+export declare function conditionTokens(condition: ItLogicCondition, context: ItLogicContext): ItLogicToken[];
+/** Tokens for one child of a group (a condition, or a nested group). */
+export declare function nodeTokens(node: ItLogicNode, context: ItLogicContext, options?: ItLogicSummaryOptions): ItLogicToken[];
+/**
+ * Tokens for a group. A nested group with several children is parenthesized.
+ * A negated group reads "not (A)" with one child and "none of (A, B)" /
+ * "not all of (A, B)" with several.
+ */
+export declare function groupTokens(group: ItLogicGroup, context: ItLogicContext, options?: ItLogicSummaryOptions, nested?: boolean): ItLogicToken[];
+/** Join tokens into text, without spaces before commas and inside parentheses. */
+export declare function tokensToText(tokens: readonly ItLogicToken[]): string;
+/** The whole tree as one plain-English sentence, with the same words the rows use. */
+export declare function summarize(root: ItLogicGroup, context: ItLogicContext, options?: ItLogicSummaryOptions & {
+    lead?: string;
+}): string;
+/** One condition as text, for accessible names: "Container name contains “Prod”". */
+export declare function summarizeCondition(condition: ItLogicCondition, context: ItLogicContext): string;
+/** A group's header in words: "Match any of the following". */
+export declare function joinSentence(group: ItLogicGroup, lead?: string): string;
+/** Scope of the `row-start` and `row-end` regions. */
+export interface ItLogicRowScope {
+    condition: ItLogicCondition;
+    field: ItLogicField | undefined;
+    depth: number;
+    index: number;
+    readonly: boolean;
+    /** Store app state on the condition (`condition.meta`). */
+    setMeta: (patch: Record<string, unknown>) => void;
+}
+/** Scope of the `group-head`, `group-foot`, and `empty` regions. */
+export interface ItLogicGroupScope {
+    group: ItLogicGroup;
+    depth: number;
+    index: number;
+    readonly: boolean;
+    addCondition: () => void;
+    /** Store app state on the group (`group.meta`). */
+    setMeta: (patch: Record<string, unknown>) => void;
+}
+/** Scope of a `value-<kind>` region (a custom operator's value editor). */
+export interface ItLogicValueScope {
+    value: unknown;
+    setValue: (value: unknown) => void;
+    field: ItLogicField | undefined;
+    operator: ItLogicOperator | undefined;
+    invalid: boolean;
+    /** Accessible name for the control: "Value for Tag name". */
+    label: string;
+    describedBy: string | undefined;
+    disabled: boolean;
+}
+export interface ItLogicBuilderState {
+    fields: ComputedRef<readonly ItLogicField[]>;
+    operators: ComputedRef<readonly ItLogicOperator[]>;
+    context: ComputedRef<ItLogicContext>;
+    root: ComputedRef<ItLogicGroup>;
+    maxDepth: ComputedRef<number>;
+    readonly: ComputedRef<boolean>;
+    disabled: ComputedRef<boolean>;
+    recentFields: ComputedRef<readonly string[]>;
+    joins: ComputedRef<readonly ItLogicJoinChoice[]>;
+    lead: ComputedRef<string>;
+    /** Issues per node id. */
+    issues: ComputedRef<Map<string, ItLogicIssue[]>>;
+    /** Inline issues show once a row was left, or after `showErrors`. */
+    shouldShowIssues: (id: string) => boolean;
+    touch: (id: string) => void;
+    /** Replace the root (v-model). */
+    commit: (root: ItLogicGroup, announcement?: string) => void;
+    announce: (message: string) => void;
+    /** Focus the first control of a node after the next render. */
+    focusNode: (id: string) => void;
+    /** Remove a node, announce it, and move focus to its neighbour (or the group's add button). */
+    remove: (id: string, announcement: string) => void;
+    /** The builder's slots, so nested parts can render its regions. */
+    slots: Slots;
+}
+export declare const IT_LOGIC_BUILDER: InjectionKey<ItLogicBuilderState>;

package/dist/components/logic/region.d.ts

@@ -0,0 +1,44 @@
+import { type PropType, type VNode } from 'vue';
+/** True when slot output contains something visible (not only comments or blank text). */
+export declare function hasVisibleContent(nodes: readonly VNode[] | undefined): boolean;
+export declare const ItLogicRegion: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    scope: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    regionClass: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    scope: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    regionClass: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    scope: Record<string, unknown>;
+    tag: string;
+    regionClass: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/components/overlays/ItDrawer.vue.d.ts

@@ -0,0 +1,48 @@
+type __VLS_Props = {
+    visible: boolean;
+    title: string;
+    /** Muted line under the title: ID · parent object, or a count ("5 platforms · 8 connections"). */
+    subtitle?: string;
+    /** md 480 · lg 720 (`--it-layout-drawer-width-*`); never wider than the viewport. */
+    size?: 'md' | 'lg';
+    /** Accessible name of the close button. */
+    closeLabel?: string;
+    /** Locks Esc, the close button, and mask clicks (e.g. while saving). */
+    busy?: boolean;
+    /** Close on mask click. */
+    dismissable?: boolean;
+    /** Unsaved work: closing asks first. Unset, the drawer asks once the person has typed in a text field. */
+    dirty?: boolean;
+};
+type __VLS_Slots = {
+    /** Above the title: severity badge, status, platform chip. */
+    eyebrow?: () => unknown;
+    /** Action row under the title (primary first). Stays in view while the body scrolls. */
+    actions?: () => unknown;
+    default?: () => unknown;
+    /** Bottom band, right-aligned: [Cancel] [Save] for drawers that edit. */
+    footer?: () => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    requestClose: () => Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:visible": (value: boolean) => any;
+    hide: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    onHide?: (() => any) | undefined;
+}>, {
+    size: "md" | "lg";
+    busy: boolean;
+    dirty: boolean;
+    dismissable: boolean;
+    subtitle: string;
+    closeLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/overlays/ItModal.vue.d.ts

@@ -0,0 +1,53 @@
+type __VLS_Props = {
+    visible: boolean;
+    title: string;
+    /** One line under the title. */
+    description?: string;
+    /** sm 400 confirm · md 560 short form · lg 800 picker · xl 1120 review flows. */
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    closable?: boolean;
+    /** Locks Esc, the close button, and outside clicks (e.g. while saving). */
+    busy?: boolean;
+    /**
+     * Unsaved work: closing asks first. Leave it unset and the modal asks
+     * once the person has typed in a text field; set it when the app knows
+     * better (work that a click outside would lose, which typing does not show).
+     */
+    dirty?: boolean;
+    /**
+     * Where focus starts. `field`: the first text field, for a form the
+     * person came to fill in. `start`: the start of the content, for a modal
+     * opened mostly to read (a step's details), so nothing looks selected.
+     */
+    initialFocus?: 'field' | 'start';
+};
+type __VLS_Slots = {
+    default?: () => unknown;
+    /** Right-aligned: [Cancel] [Primary]. */
+    footer?: () => unknown;
+    /** Left-aligned: Back, or a destructive secondary action. */
+    'footer-start'?: () => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    requestClose: () => Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:visible": (value: boolean) => any;
+    hide: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    onHide?: (() => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg" | "xl";
+    description: string;
+    closable: boolean;
+    busy: boolean;
+    dirty: boolean;
+    initialFocus: "field" | "start";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/overlays/escape-stack.d.ts

@@ -0,0 +1,7 @@
+export interface ItEscapeEntry {
+    onEscape?: (event: KeyboardEvent) => void;
+}
+/** Puts an overlay on top of the stack. Returns its removal; call it once the overlay closes. */
+export declare function itPushEscape(entry: ItEscapeEntry): () => void;
+/** Keeps a component's overlay on the stack while `visible()` is true. */
+export declare function useItEscape(visible: () => boolean, onEscape: (event: KeyboardEvent) => void): void;

package/dist/components/overlays/modal.d.ts

@@ -0,0 +1,23 @@
+import { type InjectionKey } from 'vue';
+export declare const IT_MODAL_CHANGE: InjectionKey<() => void>;
+/** Marks the enclosing ItModal or ItDrawer as holding typed text. Call it on the person's typing, never on a value the app sets. */
+export declare function useItModalChange(): () => void;
+/** Put on an element whose typing is not text worth keeping (a search box, a combobox query): it does not mark the overlay. */
+export declare const IT_MODAL_NO_CHANGE = "data-it-no-change";
+/** A field the person types into: a text-like input, a textarea, or editable content. */
+export declare const IT_TYPED_FIELD = "textarea, [contenteditable=\"\"], [contenteditable=\"true\"], input:not([type]), input[type=\"text\"], input[type=\"search\"], input[type=\"email\"], input[type=\"url\"], input[type=\"tel\"], input[type=\"number\"], input[type=\"password\"]";
+/**
+ * The closing rule, for an overlay component. `onType` goes on the content's
+ * input event; `requestClose` replaces a direct close for the close button,
+ * Esc, and a click outside.
+ */
+export declare function useItCloseGuard(options: {
+    visible: () => boolean;
+    busy: () => boolean;
+    dirty: () => boolean | undefined;
+    close: () => void;
+}): {
+    onType: (event: Event) => void;
+    requestClose: () => Promise<void>;
+    isDirty: import("vue").ComputedRef<boolean>;
+};