@entifix/react-controls 0.1.0-0

package/dist/ui/molecules/filter-builder/filter-builder.js

@@ -0,0 +1,333 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useId, useState } from 'react';
+import { useEnumLabel, useT } from '../../../i18n/index.js';
+import { Button } from '../../atoms/button/index.js';
+import { Select, TextInput } from '../../atoms/field/index.js';
+import { Text } from '../../atoms/text/index.js';
+import { operatorArity, operatorLabelKey, operatorsForType } from './filter-operators.js';
+function coerce(raw, type) {
+    if (raw === '') return undefined;
+    switch(type){
+        case 'number':
+            return Number(raw);
+        case 'boolean':
+            return raw === 'true';
+        case 'date':
+            return new Date(raw);
+        default:
+            return raw;
+    }
+}
+/**
+ * Converts a draft row into the wire filter, or `undefined` while the row is
+ * still incomplete — a half-typed row must not reach the load request.
+ */ function toFilter(draft, descriptor) {
+    const property = descriptor.key;
+    switch(operatorArity(draft.operator)){
+        case 'none':
+            return {
+                property,
+                operator: draft.operator
+            };
+        case 'list':
+            {
+                const values = draft.value.split(',').map((entry)=>entry.trim()).filter((entry)=>entry !== '').map((entry)=>coerce(entry, descriptor.type));
+                return values.length === 0 ? undefined : {
+                    property,
+                    operator: draft.operator,
+                    values
+                };
+            }
+        case 'range':
+            {
+                const start = coerce(draft.value, descriptor.type);
+                const end = coerce(draft.end, descriptor.type);
+                return start === undefined || end === undefined ? undefined : {
+                    property,
+                    operator: draft.operator,
+                    start,
+                    end
+                };
+            }
+        default:
+            {
+                const value = coerce(draft.value, descriptor.type);
+                return value === undefined ? undefined : {
+                    property,
+                    operator: draft.operator,
+                    value
+                };
+            }
+    }
+}
+/**
+ * Rebuilds the editable rows from an already-applied filter, so reopening the
+ * panel shows what is actually in effect rather than an empty form. Only the
+ * flat rows this builder can express are restored — a group nested by some
+ * other means is left to the caller to re-enter.
+ */ function toDrafts(filtering, idPrefix) {
+    if (!filtering) return [];
+    return filtering.values.flatMap((node, index)=>{
+        var _filter_start;
+        if (!('property' in node)) return [];
+        const filter = node;
+        const text = (value)=>value instanceof Date ? value.toISOString().slice(0, 10) : value === undefined ? '' : String(value);
+        return [
+            {
+                key: `${idPrefix}-applied-${index}`,
+                property: String(filter.property),
+                operator: filter.operator,
+                value: filter.values ? filter.values.map(text).join(', ') : text((_filter_start = filter.start) != null ? _filter_start : filter.value),
+                end: text(filter.end)
+            }
+        ];
+    });
+}
+/**
+ * Builds an `EntityFiltering` value from entity metadata: the member list, the
+ * operators offered and the shape of the value control all come from each
+ * member's descriptor, so no per-entity filter UI has to be written.
+ *
+ * Editing is a draft. `onChange` fires only on **Apply**, because the value
+ * feeds a load request: emitting per keystroke would put one HTTP request on
+ * the wire per character typed.
+ */ export function FilterBuilder({ descriptors, value: applied, onChange }) {
+    var _ref;
+    const t = useT();
+    const idPrefix = useId();
+    const [logic, setLogic] = useState((_ref = applied == null ? void 0 : applied.operator) != null ? _ref : 'and');
+    const [drafts, setDrafts] = useState(()=>toDrafts(applied, idPrefix));
+    const descriptorFor = useCallback((name)=>descriptors.find((entry)=>entry.name === name), [
+        descriptors
+    ]);
+    const apply = useCallback((nextDrafts, nextLogic)=>{
+        const values = nextDrafts.map((draft)=>{
+            const descriptor = descriptorFor(draft.property);
+            return descriptor ? toFilter(draft, descriptor) : undefined;
+        }).filter((filter)=>filter !== undefined);
+        onChange({
+            operator: nextLogic,
+            values
+        });
+    }, [
+        descriptorFor,
+        onChange
+    ]);
+    /** Edits the draft only — nothing reaches the caller until Apply. */ const update = (nextDrafts)=>setDrafts(nextDrafts);
+    const addRow = ()=>{
+        const first = descriptors[0];
+        // Defence in depth: the component returns early for an empty descriptor
+        // list, so this button does not exist without a first member.
+        /* v8 ignore next */ if (!first) return;
+        update([
+            ...drafts,
+            {
+                key: `${idPrefix}-${drafts.length}-${Date.now()}`,
+                property: first.name,
+                operator: operatorsForType(first.type)[0],
+                value: '',
+                end: ''
+            }
+        ]);
+    };
+    const patch = (key, changes)=>update(drafts.map((draft)=>draft.key === key ? _extends({}, draft, changes) : draft));
+    if (descriptors.length === 0) {
+        return /*#__PURE__*/ _jsx(Text, {
+            step: -1,
+            tone: "muted",
+            children: t('filter.none')
+        });
+    }
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "flex flex-col gap-2xs",
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex items-center gap-2xs",
+                children: [
+                    /*#__PURE__*/ _jsx(Text, {
+                        step: -2,
+                        tone: "muted",
+                        children: t('filter.match')
+                    }),
+                    /*#__PURE__*/ _jsxs(Select, {
+                        "aria-label": t('filter.matchAria'),
+                        value: logic,
+                        onChange: (event)=>{
+                            setLogic(event.target.value);
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx("option", {
+                                value: "and",
+                                children: t('filter.all')
+                            }),
+                            /*#__PURE__*/ _jsx("option", {
+                                value: "or",
+                                children: t('filter.any')
+                            })
+                        ]
+                    })
+                ]
+            }),
+            drafts.map((draft)=>{
+                const descriptor = descriptorFor(draft.property);
+                if (!descriptor) return null;
+                const arity = operatorArity(draft.operator);
+                return /*#__PURE__*/ _jsxs("div", {
+                    className: "flex flex-wrap items-center gap-2xs",
+                    children: [
+                        /*#__PURE__*/ _jsx(Select, {
+                            "aria-label": t('filter.member'),
+                            value: draft.property,
+                            onChange: (event)=>{
+                                const next = descriptorFor(event.target.value);
+                                // Defence in depth: the options are built from `descriptors`,
+                                // so a chosen value always resolves.
+                                /* v8 ignore next */ if (!next) return;
+                                patch(draft.key, {
+                                    property: next.name,
+                                    // The previous operator may not exist for the new type.
+                                    operator: operatorsForType(next.type)[0],
+                                    value: '',
+                                    end: ''
+                                });
+                            },
+                            children: descriptors.map((entry)=>/*#__PURE__*/ _jsx("option", {
+                                    value: entry.name,
+                                    children: entry.label
+                                }, entry.name))
+                        }),
+                        /*#__PURE__*/ _jsx(Select, {
+                            "aria-label": t('filter.operator'),
+                            value: draft.operator,
+                            onChange: (event)=>patch(draft.key, {
+                                    operator: event.target.value
+                                }),
+                            children: operatorsForType(descriptor.type).map((operator)=>/*#__PURE__*/ _jsx("option", {
+                                    value: operator,
+                                    children: t(operatorLabelKey(operator))
+                                }, operator))
+                        }),
+                        arity !== 'none' && /*#__PURE__*/ _jsx(FilterValueInput, {
+                            descriptor: descriptor,
+                            arity: arity,
+                            value: draft.value,
+                            end: draft.end,
+                            onValueChange: (value)=>patch(draft.key, {
+                                    value
+                                }),
+                            onEndChange: (end)=>patch(draft.key, {
+                                    end
+                                })
+                        }),
+                        /*#__PURE__*/ _jsx(Button, {
+                            type: "button",
+                            variant: "ghost",
+                            size: "sm",
+                            "aria-label": t('filter.remove'),
+                            onClick: ()=>update(drafts.filter((entry)=>entry.key !== draft.key)),
+                            children: "✕"
+                        })
+                    ]
+                }, draft.key);
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap items-center gap-2xs",
+                children: [
+                    /*#__PURE__*/ _jsx(Button, {
+                        type: "button",
+                        variant: "secondary",
+                        size: "sm",
+                        onClick: addRow,
+                        children: t('filter.add')
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        type: "button",
+                        variant: "primary",
+                        size: "sm",
+                        "aria-label": t('filter.applyAria'),
+                        onClick: ()=>apply(drafts, logic),
+                        children: t('filter.apply')
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        type: "button",
+                        variant: "ghost",
+                        size: "sm",
+                        "aria-label": t('filter.clearAria'),
+                        onClick: ()=>{
+                            setDrafts([]);
+                            setLogic('and');
+                            // Applying the emptied form is what actually clears the listing;
+                            // dropping the rows alone would leave the old filter in effect.
+                            apply([], 'and');
+                        },
+                        children: t('filter.clear')
+                    })
+                ]
+            })
+        ]
+    });
+}
+/** The value control the member's type calls for. */ function FilterValueInput({ descriptor, arity, value, end, onValueChange, onEndChange }) {
+    const t = useT();
+    const enumLabel = useEnumLabel();
+    if (descriptor.type === 'boolean') {
+        return /*#__PURE__*/ _jsxs(Select, {
+            "aria-label": t('filter.value'),
+            value: value,
+            onChange: (event)=>onValueChange(event.target.value),
+            children: [
+                /*#__PURE__*/ _jsx("option", {
+                    value: "",
+                    children: "—"
+                }),
+                /*#__PURE__*/ _jsx("option", {
+                    value: "true",
+                    children: t('value.yes')
+                }),
+                /*#__PURE__*/ _jsx("option", {
+                    value: "false",
+                    children: t('value.no')
+                })
+            ]
+        });
+    }
+    if (descriptor.type === 'enum' && descriptor.enumValues && arity !== 'list') {
+        return /*#__PURE__*/ _jsxs(Select, {
+            "aria-label": t('filter.value'),
+            value: value,
+            onChange: (event)=>onValueChange(event.target.value),
+            children: [
+                /*#__PURE__*/ _jsx("option", {
+                    value: "",
+                    children: "—"
+                }),
+                descriptor.enumValues.map((option)=>/*#__PURE__*/ _jsx("option", {
+                        value: option,
+                        children: enumLabel(descriptor, option)
+                    }, option))
+            ]
+        });
+    }
+    const inputType = descriptor.type === 'number' ? 'number' : descriptor.type === 'date' ? 'date' : 'text';
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(TextInput, {
+                "aria-label": t('filter.value'),
+                type: arity === 'list' ? 'text' : inputType,
+                placeholder: arity === 'list' ? t('filter.listPlaceholder') : undefined,
+                value: value,
+                onChange: (event)=>onValueChange(event.target.value)
+            }),
+            arity === 'range' && /*#__PURE__*/ _jsx(TextInput, {
+                "aria-label": t('filter.rangeEnd'),
+                type: inputType,
+                value: end,
+                onChange: (event)=>onEndChange(event.target.value)
+            })
+        ]
+    });
+}
+
+//# sourceMappingURL=filter-builder.js.map

package/dist/ui/molecules/filter-builder/filter-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/molecules/filter-builder/filter-builder.tsx"],"sourcesContent":["'use client';\n\nimport type {\n  Entity,\n  EntityFieldDescriptor,\n  EntityFilter,\n  FilterGroup,\n  LogicOperator,\n  MetaAccessorType,\n} from '@entifix/core';\nimport { useCallback, useId, useState } from 'react';\n\nimport { useEnumLabel, useT } from '../../../i18n/index.js';\nimport { Button } from '../../atoms/button/index.js';\nimport { Select, TextInput } from '../../atoms/field/index.js';\nimport { Text } from '../../atoms/text/index.js';\nimport {\n  type EntityFilterOperator,\n  operatorArity,\n  operatorLabelKey,\n  operatorsForType,\n} from './filter-operators.js';\n\n/**\n * One in-progress filter row. Values are held as strings because that is what\n * the inputs produce; they are coerced to the member's type only when the row\n * is converted into an {@link EntityFilter}.\n */\ninterface FilterDraft {\n  key: string;\n  property: string;\n  operator: EntityFilterOperator;\n  value: string;\n  end: string;\n}\n\nfunction coerce(raw: string, type: MetaAccessorType): unknown {\n  if (raw === '') return undefined;\n  switch (type) {\n    case 'number':\n      return Number(raw);\n    case 'boolean':\n      return raw === 'true';\n    case 'date':\n      return new Date(raw);\n    default:\n      return raw;\n  }\n}\n\n/**\n * Converts a draft row into the wire filter, or `undefined` while the row is\n * still incomplete — a half-typed row must not reach the load request.\n */\nfunction toFilter<TEntity extends Entity>(\n  draft: FilterDraft,\n  descriptor: EntityFieldDescriptor,\n): EntityFilter<TEntity> | undefined {\n  const property = descriptor.key as keyof TEntity;\n\n  switch (operatorArity(draft.operator)) {\n    case 'none':\n      return { property, operator: draft.operator } as EntityFilter<TEntity>;\n    case 'list': {\n      const values = draft.value\n        .split(',')\n        .map(entry => entry.trim())\n        .filter(entry => entry !== '')\n        .map(entry => coerce(entry, descriptor.type));\n      return values.length === 0\n        ? undefined\n        : ({\n            property,\n            operator: draft.operator,\n            values,\n          } as EntityFilter<TEntity>);\n    }\n    case 'range': {\n      const start = coerce(draft.value, descriptor.type);\n      const end = coerce(draft.end, descriptor.type);\n      return start === undefined || end === undefined\n        ? undefined\n        : ({\n            property,\n            operator: draft.operator,\n            start,\n            end,\n          } as EntityFilter<TEntity>);\n    }\n    default: {\n      const value = coerce(draft.value, descriptor.type);\n      return value === undefined\n        ? undefined\n        : ({\n            property,\n            operator: draft.operator,\n            value,\n          } as EntityFilter<TEntity>);\n    }\n  }\n}\n\n/**\n * Rebuilds the editable rows from an already-applied filter, so reopening the\n * panel shows what is actually in effect rather than an empty form. Only the\n * flat rows this builder can express are restored — a group nested by some\n * other means is left to the caller to re-enter.\n */\nfunction toDrafts<TEntity extends Entity>(\n  filtering: FilterGroup<TEntity> | undefined,\n  idPrefix: string,\n): FilterDraft[] {\n  if (!filtering) return [];\n\n  return filtering.values.flatMap((node, index) => {\n    if (!('property' in node)) return [];\n    const filter = node as {\n      property: unknown;\n      operator: EntityFilterOperator;\n      value?: unknown;\n      values?: unknown[];\n      start?: unknown;\n      end?: unknown;\n    };\n    const text = (value: unknown) =>\n      value instanceof Date\n        ? value.toISOString().slice(0, 10)\n        : value === undefined\n          ? ''\n          : String(value);\n\n    return [\n      {\n        key: `${idPrefix}-applied-${index}`,\n        property: String(filter.property),\n        operator: filter.operator,\n        value: filter.values\n          ? filter.values.map(text).join(', ')\n          : text(filter.start ?? filter.value),\n        end: text(filter.end),\n      },\n    ];\n  });\n}\n\nexport interface FilterBuilderProps<TEntity extends Entity> {\n  /** Filterable members, already resolved from the entity metadata. */\n  descriptors: readonly EntityFieldDescriptor[];\n  /** The filtering currently applied, used to seed the rows. */\n  value?: FilterGroup<TEntity>;\n  onChange: (filtering: FilterGroup<TEntity>) => void;\n}\n\n/**\n * Builds an `EntityFiltering` value from entity metadata: the member list, the\n * operators offered and the shape of the value control all come from each\n * member's descriptor, so no per-entity filter UI has to be written.\n *\n * Editing is a draft. `onChange` fires only on **Apply**, because the value\n * feeds a load request: emitting per keystroke would put one HTTP request on\n * the wire per character typed.\n */\nexport function FilterBuilder<TEntity extends Entity>({\n  descriptors,\n  value: applied,\n  onChange,\n}: FilterBuilderProps<TEntity>) {\n  const t = useT();\n  const idPrefix = useId();\n  const [logic, setLogic] = useState<LogicOperator>(applied?.operator ?? 'and');\n  const [drafts, setDrafts] = useState<FilterDraft[]>(() =>\n    toDrafts(applied, idPrefix),\n  );\n\n  const descriptorFor = useCallback(\n    (name: string) => descriptors.find(entry => entry.name === name),\n    [descriptors],\n  );\n\n  const apply = useCallback(\n    (nextDrafts: FilterDraft[], nextLogic: LogicOperator) => {\n      const values = nextDrafts\n        .map(draft => {\n          const descriptor = descriptorFor(draft.property);\n          return descriptor ? toFilter<TEntity>(draft, descriptor) : undefined;\n        })\n        .filter(\n          (filter): filter is EntityFilter<TEntity> => filter !== undefined,\n        );\n\n      onChange({ operator: nextLogic, values });\n    },\n    [descriptorFor, onChange],\n  );\n\n  /** Edits the draft only — nothing reaches the caller until Apply. */\n  const update = (nextDrafts: FilterDraft[]) => setDrafts(nextDrafts);\n\n  const addRow = () => {\n    const first = descriptors[0];\n    // Defence in depth: the component returns early for an empty descriptor\n    // list, so this button does not exist without a first member.\n    /* v8 ignore next */\n    if (!first) return;\n    update([\n      ...drafts,\n      {\n        key: `${idPrefix}-${drafts.length}-${Date.now()}`,\n        property: first.name,\n        operator: operatorsForType(first.type)[0],\n        value: '',\n        end: '',\n      },\n    ]);\n  };\n\n  const patch = (key: string, changes: Partial<FilterDraft>) =>\n    update(\n      drafts.map(draft =>\n        draft.key === key ? { ...draft, ...changes } : draft,\n      ),\n    );\n\n  if (descriptors.length === 0) {\n    return (\n      <Text step={-1} tone=\"muted\">\n        {t('filter.none')}\n      </Text>\n    );\n  }\n\n  return (\n    <div className=\"flex flex-col gap-2xs\">\n      <div className=\"flex items-center gap-2xs\">\n        <Text step={-2} tone=\"muted\">\n          {t('filter.match')}\n        </Text>\n        <Select\n          aria-label={t('filter.matchAria')}\n          value={logic}\n          onChange={event => {\n            setLogic(event.target.value as LogicOperator);\n          }}\n        >\n          <option value=\"and\">{t('filter.all')}</option>\n          <option value=\"or\">{t('filter.any')}</option>\n        </Select>\n      </div>\n\n      {drafts.map(draft => {\n        const descriptor = descriptorFor(draft.property);\n        if (!descriptor) return null;\n        const arity = operatorArity(draft.operator);\n\n        return (\n          <div key={draft.key} className=\"flex flex-wrap items-center gap-2xs\">\n            <Select\n              aria-label={t('filter.member')}\n              value={draft.property}\n              onChange={event => {\n                const next = descriptorFor(event.target.value);\n                // Defence in depth: the options are built from `descriptors`,\n                // so a chosen value always resolves.\n                /* v8 ignore next */\n                if (!next) return;\n                patch(draft.key, {\n                  property: next.name,\n                  // The previous operator may not exist for the new type.\n                  operator: operatorsForType(next.type)[0],\n                  value: '',\n                  end: '',\n                });\n              }}\n            >\n              {descriptors.map(entry => (\n                <option key={entry.name} value={entry.name}>\n                  {entry.label}\n                </option>\n              ))}\n            </Select>\n\n            <Select\n              aria-label={t('filter.operator')}\n              value={draft.operator}\n              onChange={event =>\n                patch(draft.key, {\n                  operator: event.target.value as EntityFilterOperator,\n                })\n              }\n            >\n              {operatorsForType(descriptor.type).map(operator => (\n                <option key={operator} value={operator}>\n                  {t(operatorLabelKey(operator))}\n                </option>\n              ))}\n            </Select>\n\n            {arity !== 'none' && (\n              <FilterValueInput\n                descriptor={descriptor}\n                arity={arity}\n                value={draft.value}\n                end={draft.end}\n                onValueChange={value => patch(draft.key, { value })}\n                onEndChange={end => patch(draft.key, { end })}\n              />\n            )}\n\n            <Button\n              type=\"button\"\n              variant=\"ghost\"\n              size=\"sm\"\n              aria-label={t('filter.remove')}\n              onClick={() =>\n                update(drafts.filter(entry => entry.key !== draft.key))\n              }\n            >\n              ✕\n            </Button>\n          </div>\n        );\n      })}\n\n      <div className=\"flex flex-wrap items-center gap-2xs\">\n        <Button type=\"button\" variant=\"secondary\" size=\"sm\" onClick={addRow}>\n          {t('filter.add')}\n        </Button>\n        <Button\n          type=\"button\"\n          variant=\"primary\"\n          size=\"sm\"\n          aria-label={t('filter.applyAria')}\n          onClick={() => apply(drafts, logic)}\n        >\n          {t('filter.apply')}\n        </Button>\n        <Button\n          type=\"button\"\n          variant=\"ghost\"\n          size=\"sm\"\n          aria-label={t('filter.clearAria')}\n          onClick={() => {\n            setDrafts([]);\n            setLogic('and');\n            // Applying the emptied form is what actually clears the listing;\n            // dropping the rows alone would leave the old filter in effect.\n            apply([], 'and');\n          }}\n        >\n          {t('filter.clear')}\n        </Button>\n      </div>\n    </div>\n  );\n}\n\ninterface FilterValueInputProps {\n  descriptor: EntityFieldDescriptor;\n  arity: ReturnType<typeof operatorArity>;\n  value: string;\n  end: string;\n  onValueChange: (value: string) => void;\n  onEndChange: (end: string) => void;\n}\n\n/** The value control the member's type calls for. */\nfunction FilterValueInput({\n  descriptor,\n  arity,\n  value,\n  end,\n  onValueChange,\n  onEndChange,\n}: FilterValueInputProps) {\n  const t = useT();\n  const enumLabel = useEnumLabel();\n\n  if (descriptor.type === 'boolean') {\n    return (\n      <Select\n        aria-label={t('filter.value')}\n        value={value}\n        onChange={event => onValueChange(event.target.value)}\n      >\n        <option value=\"\">—</option>\n        <option value=\"true\">{t('value.yes')}</option>\n        <option value=\"false\">{t('value.no')}</option>\n      </Select>\n    );\n  }\n\n  if (descriptor.type === 'enum' && descriptor.enumValues && arity !== 'list') {\n    return (\n      <Select\n        aria-label={t('filter.value')}\n        value={value}\n        onChange={event => onValueChange(event.target.value)}\n      >\n        <option value=\"\">—</option>\n        {descriptor.enumValues.map(option => (\n          <option key={option} value={option}>\n            {enumLabel(descriptor, option)}\n          </option>\n        ))}\n      </Select>\n    );\n  }\n\n  const inputType =\n    descriptor.type === 'number'\n      ? 'number'\n      : descriptor.type === 'date'\n        ? 'date'\n        : 'text';\n\n  return (\n    <>\n      <TextInput\n        aria-label={t('filter.value')}\n        type={arity === 'list' ? 'text' : inputType}\n        placeholder={arity === 'list' ? t('filter.listPlaceholder') : undefined}\n        value={value}\n        onChange={event => onValueChange(event.target.value)}\n      />\n      {arity === 'range' && (\n        <TextInput\n          aria-label={t('filter.rangeEnd')}\n          type={inputType}\n          value={end}\n          onChange={event => onEndChange(event.target.value)}\n        />\n      )}\n    </>\n  );\n}\n"],"names":["useCallback","useId","useState","useEnumLabel","useT","Button","Select","TextInput","Text","operatorArity","operatorLabelKey","operatorsForType","coerce","raw","type","undefined","Number","Date","toFilter","draft","descriptor","property","key","operator","values","value","split","map","entry","trim","filter","length","start","end","toDrafts","filtering","idPrefix","flatMap","node","index","text","toISOString","slice","String","join","FilterBuilder","descriptors","applied","onChange","t","logic","setLogic","drafts","setDrafts","descriptorFor","name","find","apply","nextDrafts","nextLogic","update","addRow","first","now","patch","changes","step","tone","div","className","aria-label","event","target","option","arity","next","label","FilterValueInput","onValueChange","onEndChange","variant","size","onClick","enumLabel","enumValues","inputType","placeholder"],"mappings":"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"}

package/dist/ui/molecules/filter-builder/filter-operators.d.ts

@@ -0,0 +1,20 @@
+import { EntityFilterArrayOperators, EntityFilterBinaryOperators, EntityFilterNullOperators, EntityFilterRangeOperators, EntityFilterStringOperators, type MetaAccessorType } from '@entifix/core';
+export type EntityFilterOperator = (typeof EntityFilterBinaryOperators)[number] | (typeof EntityFilterArrayOperators)[number] | (typeof EntityFilterRangeOperators)[number] | (typeof EntityFilterStringOperators)[number] | (typeof EntityFilterNullOperators)[number];
+/**
+ * The catalog key for an operator's user-facing name. The operator token and the
+ * key share a shape by construction, so adding an operator cannot leave a label
+ * behind: `controls.operator` is typed, and a missing entry fails to compile.
+ *
+ * Not to be confused with `RSQL_TOKENS` in `@entifix/core` — those are wire
+ * tokens (`==`, `=gt=`) and are never translated.
+ */
+export declare function operatorLabelKey(operator: EntityFilterOperator): `operator.${EntityFilterOperator}`;
+/**
+ * Operators a user can pick for a given member type. Ordering comparisons make
+ * no sense for a boolean, and substring matching makes none for a number — the
+ * type is what keeps the control from offering nonsense.
+ */
+export declare function operatorsForType(type: MetaAccessorType): readonly EntityFilterOperator[];
+/** Range operators take two bounds; array operators take a list; null ops none. */
+export declare function operatorArity(operator: EntityFilterOperator): 'none' | 'single' | 'list' | 'range';
+//# sourceMappingURL=filter-operators.d.ts.map

package/dist/ui/molecules/filter-builder/filter-operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-operators.d.ts","sourceRoot":"","sources":["../../../../src/ui/molecules/filter-builder/filter-operators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,KAAK,gBAAgB,EACtB,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,oBAAoB,GAC5B,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,GAC5C,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,GAC3C,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,GAC3C,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,GAC5C,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,oBAAoB,GAC7B,YAAY,oBAAoB,EAAE,CAEpC;AAOD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,gBAAgB,GACrB,SAAS,oBAAoB,EAAE,CAsBjC;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,oBAAoB,GAC7B,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAQtC"}

package/dist/ui/molecules/filter-builder/filter-operators.js

@@ -0,0 +1,56 @@
+import { EntityFilterArrayOperators, EntityFilterBinaryOperators, EntityFilterNullOperators, EntityFilterRangeOperators, EntityFilterStringOperators } from '@entifix/core';
+/**
+ * The catalog key for an operator's user-facing name. The operator token and the
+ * key share a shape by construction, so adding an operator cannot leave a label
+ * behind: `controls.operator` is typed, and a missing entry fails to compile.
+ *
+ * Not to be confused with `RSQL_TOKENS` in `@entifix/core` — those are wire
+ * tokens (`==`, `=gt=`) and are never translated.
+ */ export function operatorLabelKey(operator) {
+    return `operator.${operator}`;
+}
+const ORDERED = [
+    ...EntityFilterBinaryOperators,
+    ...EntityFilterRangeOperators
+];
+/**
+ * Operators a user can pick for a given member type. Ordering comparisons make
+ * no sense for a boolean, and substring matching makes none for a number — the
+ * type is what keeps the control from offering nonsense.
+ */ export function operatorsForType(type) {
+    switch(type){
+        case 'number':
+        case 'date':
+            return [
+                ...ORDERED,
+                ...EntityFilterNullOperators
+            ];
+        case 'boolean':
+            return [
+                'eq',
+                'ne'
+            ];
+        case 'enum':
+            return [
+                'eq',
+                'ne',
+                ...EntityFilterArrayOperators,
+                ...EntityFilterNullOperators
+            ];
+        default:
+            return [
+                ...EntityFilterStringOperators,
+                'eq',
+                'ne',
+                ...EntityFilterNullOperators
+            ];
+    }
+}
+/** Range operators take two bounds; array operators take a list; null ops none. */ export function operatorArity(operator) {
+    if (EntityFilterNullOperators.includes(operator)) return 'none';
+    if (EntityFilterRangeOperators.includes(operator)) return 'range';
+    if (EntityFilterArrayOperators.includes(operator)) return 'list';
+    return 'single';
+}
+
+//# sourceMappingURL=filter-operators.js.map

package/dist/ui/molecules/filter-builder/filter-operators.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/molecules/filter-builder/filter-operators.ts"],"sourcesContent":["import {\n  EntityFilterArrayOperators,\n  EntityFilterBinaryOperators,\n  EntityFilterNullOperators,\n  EntityFilterRangeOperators,\n  EntityFilterStringOperators,\n  type MetaAccessorType,\n} from '@entifix/core';\n\nexport type EntityFilterOperator =\n  | (typeof EntityFilterBinaryOperators)[number]\n  | (typeof EntityFilterArrayOperators)[number]\n  | (typeof EntityFilterRangeOperators)[number]\n  | (typeof EntityFilterStringOperators)[number]\n  | (typeof EntityFilterNullOperators)[number];\n\n/**\n * The catalog key for an operator's user-facing name. The operator token and the\n * key share a shape by construction, so adding an operator cannot leave a label\n * behind: `controls.operator` is typed, and a missing entry fails to compile.\n *\n * Not to be confused with `RSQL_TOKENS` in `@entifix/core` — those are wire\n * tokens (`==`, `=gt=`) and are never translated.\n */\nexport function operatorLabelKey(\n  operator: EntityFilterOperator,\n): `operator.${EntityFilterOperator}` {\n  return `operator.${operator}`;\n}\n\nconst ORDERED: readonly EntityFilterOperator[] = [\n  ...EntityFilterBinaryOperators,\n  ...EntityFilterRangeOperators,\n];\n\n/**\n * Operators a user can pick for a given member type. Ordering comparisons make\n * no sense for a boolean, and substring matching makes none for a number — the\n * type is what keeps the control from offering nonsense.\n */\nexport function operatorsForType(\n  type: MetaAccessorType,\n): readonly EntityFilterOperator[] {\n  switch (type) {\n    case 'number':\n    case 'date':\n      return [...ORDERED, ...EntityFilterNullOperators];\n    case 'boolean':\n      return ['eq', 'ne'];\n    case 'enum':\n      return [\n        'eq',\n        'ne',\n        ...EntityFilterArrayOperators,\n        ...EntityFilterNullOperators,\n      ];\n    default:\n      return [\n        ...EntityFilterStringOperators,\n        'eq',\n        'ne',\n        ...EntityFilterNullOperators,\n      ];\n  }\n}\n\n/** Range operators take two bounds; array operators take a list; null ops none. */\nexport function operatorArity(\n  operator: EntityFilterOperator,\n): 'none' | 'single' | 'list' | 'range' {\n  if ((EntityFilterNullOperators as readonly string[]).includes(operator))\n    return 'none';\n  if ((EntityFilterRangeOperators as readonly string[]).includes(operator))\n    return 'range';\n  if ((EntityFilterArrayOperators as readonly string[]).includes(operator))\n    return 'list';\n  return 'single';\n}\n"],"names":["EntityFilterArrayOperators","EntityFilterBinaryOperators","EntityFilterNullOperators","EntityFilterRangeOperators","EntityFilterStringOperators","operatorLabelKey","operator","ORDERED","operatorsForType","type","operatorArity","includes"],"mappings":"AAAA,SACEA,0BAA0B,EAC1BC,2BAA2B,EAC3BC,yBAAyB,EACzBC,0BAA0B,EAC1BC,2BAA2B,QAEtB,gBAAgB;AASvB;;;;;;;CAOC,GACD,OAAO,SAASC,iBACdC,QAA8B;IAE9B,OAAO,CAAC,SAAS,EAAEA,UAAU;AAC/B;AAEA,MAAMC,UAA2C;OAC5CN;OACAE;CACJ;AAED;;;;CAIC,GACD,OAAO,SAASK,iBACdC,IAAsB;IAEtB,OAAQA;QACN,KAAK;QACL,KAAK;YACH,OAAO;mBAAIF;mBAAYL;aAA0B;QACnD,KAAK;YACH,OAAO;gBAAC;gBAAM;aAAK;QACrB,KAAK;YACH,OAAO;gBACL;gBACA;mBACGF;mBACAE;aACJ;QACH;YACE,OAAO;mBACFE;gBACH;gBACA;mBACGF;aACJ;IACL;AACF;AAEA,iFAAiF,GACjF,OAAO,SAASQ,cACdJ,QAA8B;IAE9B,IAAI,AAACJ,0BAAgDS,QAAQ,CAACL,WAC5D,OAAO;IACT,IAAI,AAACH,2BAAiDQ,QAAQ,CAACL,WAC7D,OAAO;IACT,IAAI,AAACN,2BAAiDW,QAAQ,CAACL,WAC7D,OAAO;IACT,OAAO;AACT"}

package/dist/ui/molecules/filter-builder/index.d.ts

@@ -0,0 +1,3 @@
+export * from './filter-builder.js';
+export * from './filter-operators.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/molecules/filter-builder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/molecules/filter-builder/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}

package/dist/ui/molecules/filter-builder/index.js

@@ -0,0 +1,4 @@
+export * from './filter-builder.js';
+export * from './filter-operators.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ui/molecules/filter-builder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/molecules/filter-builder/index.ts"],"sourcesContent":["export * from './filter-builder.js';\nexport * from './filter-operators.js';\n"],"names":[],"mappings":"AAAA,cAAc,sBAAsB;AACpC,cAAc,wBAAwB"}

package/dist/ui/molecules/loading-boundary/index.d.ts

@@ -0,0 +1,2 @@
+export * from './loading-boundary.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/molecules/loading-boundary/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/molecules/loading-boundary/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/ui/molecules/loading-boundary/index.js

@@ -0,0 +1,3 @@
+export * from './loading-boundary.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ui/molecules/loading-boundary/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/molecules/loading-boundary/index.ts"],"sourcesContent":["export * from './loading-boundary.js';\n"],"names":[],"mappings":"AAAA,cAAc,wBAAwB"}

package/dist/ui/molecules/loading-boundary/loading-boundary.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+export interface LoadingBoundaryProps {
+    isLoading: boolean;
+    children: ReactNode;
+    /** What to show while loading. Defaults to a shape-matched skeleton. */
+    fallback?: ReactNode;
+    /** Lines for the default text fallback. `0` renders a single block instead. */
+    lines?: number;
+    className?: string;
+    /** Announced to assistive tech; a catalog key resolved by the caller. */
+    label?: string;
+}
+/**
+ * Holds a region's shape while its content is still arriving.
+ *
+ * Presentational and copy-free: it renders a skeleton, not the word "Loading",
+ * because a placeholder that matches the real geometry causes no layout shift
+ * when the content lands and needs no translation. The optional {@link label} is
+ * for screen readers only — the visual skeleton is `aria-hidden`, so without it
+ * a non-sighted caller is told nothing at all while a region is pending.
+ *
+ * It is not an error boundary and does not catch anything. Rendering actions
+ * became asynchronous when affordances moved behind `$metadata` (ADR 0026);
+ * this is where that wait is shown.
+ */
+export declare function LoadingBoundary({ isLoading, children, fallback, lines, className, label, }: LoadingBoundaryProps): import("react").JSX.Element;
+//# sourceMappingURL=loading-boundary.d.ts.map

package/dist/ui/molecules/loading-boundary/loading-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-boundary.d.ts","sourceRoot":"","sources":["../../../../src/ui/molecules/loading-boundary/loading-boundary.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAKvC,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,SAAS,CAAC;IACpB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,+EAA+E;IAC/E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,EAC9B,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,KAAS,EACT,SAAS,EACT,KAAK,GACN,EAAE,oBAAoB,+BAsBtB"}

package/dist/ui/molecules/loading-boundary/loading-boundary.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Skeleton, SkeletonText } from '../../atoms/skeleton/index.js';
+import { cn } from '../../utils/cn.js';
+/**
+ * Holds a region's shape while its content is still arriving.
+ *
+ * Presentational and copy-free: it renders a skeleton, not the word "Loading",
+ * because a placeholder that matches the real geometry causes no layout shift
+ * when the content lands and needs no translation. The optional {@link label} is
+ * for screen readers only — the visual skeleton is `aria-hidden`, so without it
+ * a non-sighted caller is told nothing at all while a region is pending.
+ *
+ * It is not an error boundary and does not catch anything. Rendering actions
+ * became asynchronous when affordances moved behind `$metadata` (ADR 0026);
+ * this is where that wait is shown.
+ */ export function LoadingBoundary({ isLoading, children, fallback, lines = 3, className, label }) {
+    if (!isLoading) {
+        return /*#__PURE__*/ _jsx(_Fragment, {
+            children: children
+        });
+    }
+    return /*#__PURE__*/ _jsxs("div", {
+        "data-testid": "loading-boundary",
+        className: cn(className),
+        role: "status",
+        "aria-busy": "true",
+        "aria-live": "polite",
+        children: [
+            label && /*#__PURE__*/ _jsx("span", {
+                className: "sr-only",
+                children: label
+            }),
+            fallback != null ? fallback : lines === 0 ? /*#__PURE__*/ _jsx(Skeleton, {
+                className: "h-8 w-full"
+            }) : /*#__PURE__*/ _jsx(SkeletonText, {
+                lines: lines
+            })
+        ]
+    });
+}
+
+//# sourceMappingURL=loading-boundary.js.map

package/dist/ui/molecules/loading-boundary/loading-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/molecules/loading-boundary/loading-boundary.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\n\nimport { Skeleton, SkeletonText } from '../../atoms/skeleton/index.js';\nimport { cn } from '../../utils/cn.js';\n\nexport interface LoadingBoundaryProps {\n  isLoading: boolean;\n  children: ReactNode;\n  /** What to show while loading. Defaults to a shape-matched skeleton. */\n  fallback?: ReactNode;\n  /** Lines for the default text fallback. `0` renders a single block instead. */\n  lines?: number;\n  className?: string;\n  /** Announced to assistive tech; a catalog key resolved by the caller. */\n  label?: string;\n}\n\n/**\n * Holds a region's shape while its content is still arriving.\n *\n * Presentational and copy-free: it renders a skeleton, not the word \"Loading\",\n * because a placeholder that matches the real geometry causes no layout shift\n * when the content lands and needs no translation. The optional {@link label} is\n * for screen readers only — the visual skeleton is `aria-hidden`, so without it\n * a non-sighted caller is told nothing at all while a region is pending.\n *\n * It is not an error boundary and does not catch anything. Rendering actions\n * became asynchronous when affordances moved behind `$metadata` (ADR 0026);\n * this is where that wait is shown.\n */\nexport function LoadingBoundary({\n  isLoading,\n  children,\n  fallback,\n  lines = 3,\n  className,\n  label,\n}: LoadingBoundaryProps) {\n  if (!isLoading) {\n    return <>{children}</>;\n  }\n\n  return (\n    <div\n      data-testid=\"loading-boundary\"\n      className={cn(className)}\n      role=\"status\"\n      aria-busy=\"true\"\n      aria-live=\"polite\"\n    >\n      {label && <span className=\"sr-only\">{label}</span>}\n      {fallback ??\n        (lines === 0 ? (\n          <Skeleton className=\"h-8 w-full\" />\n        ) : (\n          <SkeletonText lines={lines} />\n        ))}\n    </div>\n  );\n}\n"],"names":["Skeleton","SkeletonText","cn","LoadingBoundary","isLoading","children","fallback","lines","className","label","div","data-testid","role","aria-busy","aria-live","span"],"mappings":";AAEA,SAASA,QAAQ,EAAEC,YAAY,QAAQ,gCAAgC;AACvE,SAASC,EAAE,QAAQ,oBAAoB;AAcvC;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,gBAAgB,EAC9BC,SAAS,EACTC,QAAQ,EACRC,QAAQ,EACRC,QAAQ,CAAC,EACTC,SAAS,EACTC,KAAK,EACgB;IACrB,IAAI,CAACL,WAAW;QACd,qBAAO;sBAAGC;;IACZ;IAEA,qBACE,MAACK;QACCC,eAAY;QACZH,WAAWN,GAAGM;QACdI,MAAK;QACLC,aAAU;QACVC,aAAU;;YAETL,uBAAS,KAACM;gBAAKP,WAAU;0BAAWC;;YACpCH,mBAAAA,WACEC,UAAU,kBACT,KAACP;gBAASQ,WAAU;+BAEpB,KAACP;gBAAaM,OAAOA;;;;AAI/B"}

package/dist/ui/molecules/menu/index.d.ts

@@ -0,0 +1,2 @@
+export * from './menu.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/molecules/menu/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/molecules/menu/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/dist/ui/molecules/menu/index.js

@@ -0,0 +1,3 @@
+export * from './menu.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ui/molecules/menu/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/molecules/menu/index.ts"],"sourcesContent":["export * from './menu.js';\n"],"names":[],"mappings":"AAAA,cAAc,YAAY"}