bank20baht-ui 0.0.8 → 0.0.10

package/README.md

@@ -93,6 +93,21 @@ dep changes, options refetch and the dependent value clears — cascading down c
 `compare` checks against a sibling field (confirm email = `op: 'eq'`), numeric/date-aware,
 skips while either side is empty. Works inside repeater rows and on the server.
 
+### Feature flags — deploy dark, flip a JSON file
+
+```js
+// schema: gate a field / workflow step / rule
+{ order: 9, type: 'text', key: 'promoCode', flag: 'promo' }   // '!promo' = the old path
+
+// host: flags from one static file — edit it, features flip
+el.flags = await fetch('/flags.json').then((r) => r.json());  // { "promo": true }
+```
+
+Flag-off means **not in the schema**: no render, no validation (a dark `required` can't
+block), nothing in the payload. Missing keys count as off, so new features stay dark until
+the file turns them on. Server side: `validateSubmission(applyFlags(schema, flags), data)`
+with the same JSON — `bank20baht-validator` re-exports `applyFlags`.
+
 ### Drafts / autosave (host pattern)
 
 The library is controlled — autosave is three lines in your app:

package/dist/components/baht-form.d.ts

@@ -1,6 +1,6 @@
 import { TemplateResult } from 'lit';
 import { BahtElement } from './base.js';
-import { DerivedFieldState, FormDefinition, Registry, ValidationError } from '../core/types.js';
+import { DerivedFieldState, FeatureFlags, FormDefinition, Registry, ValidationError } from '../core/types.js';
 export interface BahtFormOptions {
     validateOn?: 'change' | 'blur' | 'submit';
 }
@@ -23,6 +23,11 @@ export declare class BahtForm extends BahtElement {
      * the complete schema, views never change the submit payload.
      */
     view?: string;
+    /**
+     * Feature-flag values (spec 01 §12) — fields whose `flag` is off behave as
+     * if they were never in the schema: no render, no validation, no payload.
+     */
+    flags: FeatureFlags;
     /** Edits the user made since the host last set `value` (controlled overlay). */
     private edits;
     private errors;
@@ -36,6 +41,9 @@ export declare class BahtForm extends BahtElement {
     private dynamicOptions;
     private optionsSnapshots;
     private optionsEpoch;
+    /** applyFlags result, memoized on (form, flags) identity. */
+    private flagCache;
+    private get effectiveForm();
     protected willUpdate(changed: Map<PropertyKey, unknown>): void;
     /**
      * Refetch `optionsFrom` options whose dep snapshot changed. Sync fetchers

package/dist/components/baht-workflow.d.ts

@@ -1,6 +1,6 @@
 import { TemplateResult } from 'lit';
 import { BahtElement } from './base.js';
-import { NestedData, Registry, WorkflowDefinition } from '../core/types.js';
+import { FeatureFlags, NestedData, Registry, WorkflowDefinition } from '../core/types.js';
 /**
  * <baht-workflow> — the optional brain (spec 03). Wraps the current form in an
  * internal <baht-form>, evaluates rules on every change, walks the visible forms
@@ -21,12 +21,17 @@ export declare class BahtWorkflow extends BahtElement {
     submitLabel?: string;
     backLabel?: string;
     showBack: boolean;
+    /** Feature-flag values (spec 01 §12): flag-off steps/fields/rules vanish. */
+    flags: FeatureFlags;
     private data;
     private derived;
     private current;
     private approvalError;
     private history;
     get currentFormName(): string | null;
+    /** applyFlags result, memoized on (workflow, flags) identity. */
+    private flagCache;
+    private get effectiveWorkflow();
     protected willUpdate(changed: Map<PropertyKey, unknown>): void;
     private reevaluate;
     /** Forms in ascending order whose derived visibility is true. */
@@ -36,6 +41,12 @@ export declare class BahtWorkflow extends BahtElement {
     private fieldStatesFor;
     private get formEl();
     getData(): NestedData;
+    /**
+     * Host/store write into one form's data — same path a user edit takes
+     * (rules reevaluate, `baht-data-change` fires) but WITHOUT the step reset
+     * that re-feeding the `value` prop causes.
+     */
+    setValue(formName: string, patch: Record<string, unknown>): void;
     next(): void;
     /** Advance past the current form: submit+complete on the last one, else step forward. */
     private advance;

package/dist/core/flags.d.ts

@@ -0,0 +1,19 @@
+import { FeatureFlags, FormDefinition, WorkflowDefinition } from './types.js';
+/**
+ * Is a `flag` expression on (spec 01 §12)?
+ * - no flag        -> always on
+ * - 'name'         -> on only while flags.name is true
+ * - '!name'        -> on only while flags.name is NOT true
+ * A missing key counts as false — new features stay dark until the flags
+ * file explicitly turns them on.
+ */
+export declare function flagEnabled(flag: string | undefined, flags: FeatureFlags): boolean;
+/**
+ * Resolve every `flag` in a definition against the current flag values:
+ * flag-off fields/steps/rules come back REMOVED, as if never authored —
+ * they don't render, don't validate, and never reach the payload. Run the
+ * same call server-side (bank20baht-validator re-exports it) with the same
+ * flags JSON so both sides agree. Returns the input untouched when nothing
+ * in it carries a flag.
+ */
+export declare function applyFlags<T extends FormDefinition | WorkflowDefinition>(schema: T, flags?: FeatureFlags): T;

package/dist/core/index.d.ts

@@ -3,6 +3,7 @@ export { defaultValue } from './defaults.js';
 export { approvalFields } from './approval.js';
 export { validateField } from './validators.js';
 export { resolveViewFields } from './views.js';
+export { applyFlags, flagEnabled } from './flags.js';
 export { setLocale, t } from './i18n.js';
 export type { Locale, MessageCatalog, MessageKey } from './i18n.js';
 export { evaluate } from './engine/evaluate.js';

package/dist/core/types.d.ts

@@ -54,6 +54,12 @@ export interface FieldDescriptor {
     maxSize?: number;
     text?: string;
     variant?: string;
+    /**
+     * Feature flag gating this field (spec 01 §12): shown only while the flag
+     * is on ('name') or off ('!name'). Flag-off = as if the field were never in
+     * the schema — not rendered, not validated, absent from the payload.
+     */
+    flag?: string;
     fields?: FieldDescriptor[];
     minRows?: number;
     maxRows?: number;
@@ -108,6 +114,8 @@ export interface WorkflowForm extends FormDefinition {
     approval?: ApprovalConfig;
     /** Name of one of this form's `views` to render for this step (display only). */
     view?: string;
+    /** Feature flag gating this whole step (spec 01 §12). */
+    flag?: string;
 }
 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. */
@@ -160,7 +168,11 @@ export interface Rule {
     when?: Condition;
     then?: Action[];
     else?: Action[];
+    /** Feature flag gating this rule (spec 01 §12). */
+    flag?: string;
 }
+/** Flag values — typically fetched from one static JSON file (spec 01 §12). */
+export type FeatureFlags = Record<string, boolean>;
 /** A Workflow definition — consumed by <baht-workflow> (spec 00 §4.2). */
 export interface WorkflowDefinition {
     workflowId: string;

package/dist/custom-elements.json

@@ -60,6 +60,15 @@
               "description": "Name of a view from `form.views`. Display-only: when set, only that view's\nfields are rendered and validated (the user can only fix what they see),\nbut getData() still returns the FULL form — the server always validates\nthe complete schema, views never change the submit payload.",
               "attribute": "view"
             },
+            {
+              "kind": "field",
+              "name": "flags",
+              "type": {
+                "text": "FeatureFlags"
+              },
+              "default": "{}",
+              "description": "Feature-flag values (spec 01 §12) — fields whose `flag` is off behave as\nif they were never in the schema: no render, no validation, no payload."
+            },
             {
               "kind": "field",
               "name": "edits",
@@ -105,6 +114,25 @@
               "privacy": "private",
               "default": "new Map<string, number>()"
             },
+            {
+              "kind": "field",
+              "name": "flagCache",
+              "type": {
+                "text": "{ form?: FormDefinition; flags?: FeatureFlags; out?: FormDefinition }"
+              },
+              "privacy": "private",
+              "default": "{}",
+              "description": "applyFlags result, memoized on (form, flags) identity."
+            },
+            {
+              "kind": "field",
+              "name": "effectiveForm",
+              "type": {
+                "text": "FormDefinition"
+              },
+              "privacy": "private",
+              "readonly": true
+            },
             {
               "kind": "method",
               "name": "syncDynamicOptions",
@@ -401,6 +429,15 @@
               "default": "true",
               "attribute": "show-back"
             },
+            {
+              "kind": "field",
+              "name": "flags",
+              "type": {
+                "text": "FeatureFlags"
+              },
+              "default": "{}",
+              "description": "Feature-flag values (spec 01 §12): flag-off steps/fields/rules vanish."
+            },
             {
               "kind": "field",
               "name": "data",
@@ -454,6 +491,25 @@
               },
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "flagCache",
+              "type": {
+                "text": "{\n    workflow?: WorkflowDefinition;\n    flags?: FeatureFlags;\n    out?: WorkflowDefinition;\n  }"
+              },
+              "privacy": "private",
+              "default": "{}",
+              "description": "applyFlags result, memoized on (workflow, flags) identity."
+            },
+            {
+              "kind": "field",
+              "name": "effectiveWorkflow",
+              "type": {
+                "text": "WorkflowDefinition"
+              },
+              "privacy": "private",
+              "readonly": true
+            },
             {
               "kind": "method",
               "name": "reevaluate",
@@ -528,6 +584,30 @@
                 }
               }
             },
+            {
+              "kind": "method",
+              "name": "setValue",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "formName",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "patch",
+                  "type": {
+                    "text": "Record<string, unknown>"
+                  }
+                }
+              ],
+              "description": "Host/store write into one form's data — same path a user edit takes\n(rules reevaluate, `baht-data-change` fires) but WITHOUT the step reset\nthat re-feeding the `value` prop causes."
+            },
             {
               "kind": "method",
               "name": "next",