bank20baht-ui 0.0.1

package/dist/components/primitives/icons.d.ts

@@ -0,0 +1,13 @@
+import { TemplateResult } from 'lit';
+/**
+ * Curated inline-SVG icon set for the design system. Intentionally small — the
+ * 20baht system uses icons sparingly (only the spinner animates). Each icon is a
+ * 16×16 currentColor stroke glyph so it inherits button/link color.
+ *
+ * Add an icon only when a component genuinely needs it; this is not a general
+ * icon library.
+ */
+export type IconName = 'copy' | 'check' | 'download' | 'upload' | 'plus' | 'external' | 'close' | 'play';
+/** Render a named icon, or `nothing`-equivalent empty when the name is unknown. */
+export declare function renderIcon(name: IconName): TemplateResult;
+export declare function isIconName(v: string): v is IconName;

package/dist/components/primitives/index.d.ts

@@ -0,0 +1,38 @@
+import { FieldType } from '../../core/types.js';
+export { BahtButton, type ButtonVariant, type ButtonSize } from './baht-button.js';
+export { renderIcon, isIconName, type IconName } from './icons.js';
+export { BahtBadge, type BadgeTone } from './baht-badge.js';
+export { BahtCode, type CodeVariant } from './baht-code.js';
+export { BahtTable, type CellRenderer } from './baht-table.js';
+export { BahtList, type ListItem } from './baht-list.js';
+export { BahtPagination } from './baht-pagination.js';
+export { BahtModal } from './baht-modal.js';
+export { BahtToast, type ToastOptions } from './baht-toast.js';
+export { BahtTooltip } from './baht-tooltip.js';
+export { BahtAlert } from './baht-alert.js';
+export { BahtRating } from './baht-rating.js';
+export { BahtRange } from './baht-range.js';
+export { BahtOtp } from './baht-otp.js';
+export { BahtFilter } from './baht-filter.js';
+export { BahtSkeleton } from './baht-skeleton.js';
+export { BahtProgress } from './baht-progress.js';
+export { BahtSpinner } from './baht-spinner.js';
+export { BahtCard } from './baht-card.js';
+export { BahtFieldset } from './baht-fieldset.js';
+export { BahtTimeline, type TimelineItem } from './baht-timeline.js';
+export { BahtAccordion, type AccordionItem } from './baht-accordion.js';
+export { BahtLink } from './baht-link.js';
+export { BahtBreadcrumbs, type Crumb } from './baht-breadcrumbs.js';
+export { BahtInput } from './baht-input.js';
+export { BahtTextarea } from './baht-textarea.js';
+export { BahtNumber } from './baht-number.js';
+export { BahtSelect } from './baht-select.js';
+export { BahtMultiselect } from './baht-multiselect.js';
+export { BahtCheckbox } from './baht-checkbox.js';
+export { BahtRadio } from './baht-radio.js';
+export { BahtToggle } from './baht-toggle.js';
+export { BahtDatepicker } from './baht-datepicker.js';
+export { BahtFile } from './baht-file.js';
+export { BahtText } from './baht-text.js';
+/** field descriptor `type` -> primitive tag (used by <baht-form> and the builder). */
+export declare const TAG_FOR_TYPE: Record<FieldType, string>;

package/dist/core/approval.d.ts

@@ -0,0 +1,9 @@
+import { FieldDescriptor, WorkflowForm } from './types.js';
+/**
+ * The synthetic value-carrying fields of an approval step (spec 03 §4).
+ * The engine indexes them like authored fields so `<name>.decision` /
+ * `<name>.comment` are rule-addressable, survive `evaluate()`'s output
+ * filter, and get clear-on-skip semantics. Authored fields with the same
+ * key win (none expected in v1 — approval steps carry no authored fields).
+ */
+export declare function approvalFields(form: WorkflowForm): FieldDescriptor[];

package/dist/core/defaults.d.ts

@@ -0,0 +1,6 @@
+import { FieldDescriptor } from './types.js';
+/**
+ * A field's default value (spec 01 §1.1): its `value` if given, else the
+ * type's empty default. Clear-on-hide/skip resets to this.
+ */
+export declare function defaultValue(field: FieldDescriptor): unknown;

package/dist/core/engine/conditions.d.ts

@@ -0,0 +1,4 @@
+import { Condition, NestedData } from '../types.js';
+/** Read a "formName.fieldKey" reference out of nested data. */
+export declare function readRef(data: NestedData, ref: string): unknown;
+export declare function evalCondition(cond: Condition | undefined, data: NestedData): boolean;

package/dist/core/engine/evaluate.d.ts

@@ -0,0 +1,8 @@
+import { Derived, NestedData, WorkflowDefinition } from '../types.js';
+/**
+ * The rules engine (spec 02 §5). Pure: same inputs -> same Derived.
+ * Reactive fixpoint: reset -> eval when -> apply (priority-resolved) ->
+ * clear hidden/skipped to defaults -> setValue -> repeat until stable
+ * (cycle guard MAX_PASSES; overflow surfaces an error, never hangs).
+ */
+export declare function evaluate(workflow: WorkflowDefinition, input: NestedData): Derived;

package/dist/core/engine/expressions.d.ts

@@ -0,0 +1,3 @@
+import { NestedData, ValueExpr } from '../types.js';
+/** Wrapper that maps the div-by-zero NaN marker to null. */
+export declare function evalValueExpr(expr: ValueExpr, data: NestedData): unknown;

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export { defaultValue } from './defaults.js';
+export { approvalFields } from './approval.js';
+export { validateField } from './validators.js';
+export { evaluate } from './engine/evaluate.js';
+export { evalCondition, readRef } from './engine/conditions.js';
+export { evalValueExpr } from './engine/expressions.js';

package/dist/core/types.d.ts

@@ -0,0 +1,166 @@
+/** Control types supported by v1 (spec 01 §2). */
+export type FieldType = 'text' | 'textarea' | 'number' | 'email' | 'dropdown' | 'multiselect' | 'checkbox' | 'radio' | 'toggle' | 'date' | 'file' | 'label';
+export type FieldWidth = '1/4' | '1/2' | '3/4' | 'full';
+export interface FieldOption {
+    key: string;
+    label: string;
+}
+/** Declarative validator (spec 01 §4). `custom` resolves `fn` from the registry. */
+export interface ValidatorSpec {
+    type: 'required' | 'minLength' | 'maxLength' | 'min' | 'max' | 'pattern' | 'email' | 'custom';
+    value?: unknown;
+    fn?: string;
+    message?: string;
+}
+/** One item of `field_data[]` (spec 01 §1). */
+export interface FieldDescriptor {
+    order: number;
+    type: FieldType;
+    key: string;
+    label?: string;
+    placeholder?: string;
+    help?: string;
+    autocomplete?: string;
+    width?: FieldWidth;
+    value?: unknown;
+    disabled?: boolean;
+    required?: boolean;
+    options?: FieldOption[];
+    maxLength?: number;
+    minLength?: number;
+    min?: number | string;
+    max?: number | string;
+    step?: number;
+    rows?: number;
+    accept?: string;
+    multiple?: boolean;
+    maxSize?: number;
+    text?: string;
+    variant?: string;
+    validators?: ValidatorSpec[];
+    formatter?: string;
+}
+/** A Form definition — consumed standalone by <baht-form> (spec 00 §4.1). */
+export interface FormDefinition {
+    formId: string;
+    formName: string;
+    field_data: FieldDescriptor[];
+}
+export type ApprovalDecision = 'approved' | 'rejected';
+/** Comment box policy on an approval step. */
+export type ApprovalCommentMode = 'hidden' | 'optional' | 'requireOnReject' | 'required';
+export interface ApprovalConfig {
+    /** formNames whose data the summary shows; default = every earlier visible form. */
+    summaryForms?: string[];
+    approveLabel?: string;
+    rejectLabel?: string;
+    comment?: ApprovalCommentMode;
+    /** Reject behavior: end the workflow (default) or send the user back to a form. */
+    onReject?: {
+        action: 'end';
+    } | {
+        action: 'goto';
+        form: string;
+    };
+}
+/** A form inside a workflow: adds its position in the linear order. */
+export interface WorkflowForm extends FormDefinition {
+    order: number;
+    /**
+     * 'approval' renders a decision step (summary + Approve/Reject) instead of
+     * fields; its `decision`/`comment` values live in data like any field.
+     * Default 'form'.
+     */
+    kind?: 'form' | 'approval';
+    approval?: ApprovalConfig;
+}
+export type ConditionOp = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'isEmpty' | 'isNotEmpty';
+/** Leaf: compare `formName.fieldKey` against a constant or another field. */
+export interface FieldCondition {
+    field: string;
+    op: ConditionOp;
+    value?: unknown;
+    valueField?: string;
+}
+export type Condition = FieldCondition | {
+    and: Condition[];
+} | {
+    or: Condition[];
+} | {
+    not: Condition;
+};
+export type ValueExpr = {
+    ref: string;
+} | {
+    const: unknown;
+} | {
+    op: 'add' | 'sub' | 'mul' | 'div' | 'concat' | 'coalesce';
+    args: ValueExpr[];
+} | {
+    if: [Condition, ValueExpr, ValueExpr];
+};
+export interface FieldTarget {
+    form: string;
+    field: string;
+}
+export interface FormTarget {
+    form: string;
+}
+export type FieldActionType = 'show' | 'hide' | 'enable' | 'disable' | 'readonly' | 'required' | 'optional';
+export type Action = {
+    action: FieldActionType;
+    target: FieldTarget;
+} | {
+    action: 'setValue';
+    target: FieldTarget;
+    value: ValueExpr;
+    lock?: boolean;
+} | {
+    action: 'showForm' | 'hideForm' | 'skipForm';
+    target: FormTarget;
+};
+export interface Rule {
+    id?: string;
+    priority?: number;
+    when?: Condition;
+    then?: Action[];
+    else?: Action[];
+}
+/** A Workflow definition — consumed by <baht-workflow> (spec 00 §4.2). */
+export interface WorkflowDefinition {
+    workflowId: string;
+    forms: WorkflowForm[];
+    rules: Rule[];
+}
+export interface Registry {
+    formatters?: Record<string, (value: unknown) => unknown>;
+    /** Return null when valid, or an error message string. */
+    validators?: Record<string, (value: unknown) => string | null>;
+}
+export interface DerivedFieldState {
+    visible: boolean;
+    enabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    /** True while a setValue rule with lock (default) is active on this field. */
+    computed: boolean;
+}
+export type NestedData = Record<string, Record<string, unknown>>;
+export interface Derived {
+    /** Nested {formName: {key: value}} — possibly mutated by setValue/clears. */
+    data: NestedData;
+    /** Keyed "formName.key". */
+    fields: Record<string, DerivedFieldState>;
+    /** skipForm/hideForm result per formName. */
+    forms: Record<string, {
+        visible: boolean;
+    }>;
+    errors: Array<{
+        ref: string;
+        message: string;
+    }>;
+}
+export interface ValidationError {
+    key: string;
+    message: string;
+}

package/dist/core/validators.d.ts

@@ -0,0 +1,6 @@
+import { FieldDescriptor, Registry, ValidationError } from './types.js';
+/**
+ * Validate one field's value against its declarative validators (spec 01 §4).
+ * Empty + not required = valid (other validators only run on non-empty values).
+ */
+export declare function validateField(field: FieldDescriptor, value: unknown, registry?: Registry): ValidationError[];