@entifix/react-controls 0.1.0-0

package/dist/i18next/index.js

@@ -0,0 +1,60 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { makeFormatters } from '@entifix/core';
+import { createI18n, sharedFallbackI18n } from '@entifix/i18n';
+import { useMemo } from 'react';
+import { I18nextProvider, initReactI18next } from 'react-i18next';
+import { TranslatorProvider } from '../i18n/i18n-context.js';
+/**
+ * The i18next binding of the translator port.
+ *
+ * Behind a subpath, with `i18next`, `react-i18next` and `@entifix/i18n` as
+ * optional peers, so the controls themselves stay adoptable without any of it.
+ * Package-level dependencies are not per-subpath — the optional peers are what
+ * does the work, the same arrangement as `@entifix/mongo/transactions`.
+ */ const translatorFor = (instance, locale)=>({
+        locale,
+        formatters: makeFormatters(locale),
+        // `Translator.t` takes a plain string, because the port has to be
+        // implementable without i18next at all. i18next's own `Namespace` is whatever
+        // union the host declared, and it is not this adapter's job to know it — the
+        // key stays checked at the `useT('shell')` call site, where the augmentation
+        // is in scope.
+        t: (ns, key, params)=>{
+            const fixed = instance.getFixedT(locale, ns != null ? ns : null);
+            return fixed(key, params);
+        }
+    });
+/**
+ * Binds one locale to the subtree. A fresh i18next instance per locale keeps
+ * concurrent server renders from sharing mutable `lng` state; `I18nextProvider`
+ * carries it so any nested `useTranslation` resolves against the same catalogs.
+ */ export function I18nProvider({ locale, children }) {
+    const instance = useMemo(()=>createI18n(locale, [
+            initReactI18next
+        ]), [
+        locale
+    ]);
+    const translator = useMemo(()=>translatorFor(instance, locale), [
+        instance,
+        locale
+    ]);
+    return /*#__PURE__*/ _jsx(TranslatorProvider, {
+        translator: translator,
+        children: /*#__PURE__*/ _jsx(I18nextProvider, {
+            i18n: instance,
+            children: children
+        })
+    });
+}
+/**
+ * A translator over the shared fallback instance, for a caller that has
+ * catalogs installed but no provider in the tree — a spec, a Storybook
+ * decorator that renders one control.
+ */ export function fallbackI18nextTranslator(locale) {
+    return translatorFor(sharedFallbackI18n([
+        initReactI18next
+    ]), locale);
+}
+
+//# sourceMappingURL=index.js.map

package/dist/i18next/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18next/index.tsx"],"sourcesContent":["'use client';\n\nimport { type Locale, makeFormatters } from '@entifix/core';\nimport { createI18n, sharedFallbackI18n } from '@entifix/i18n';\nimport type { i18n as I18nInstance } from 'i18next';\nimport { type PropsWithChildren, useMemo } from 'react';\nimport { I18nextProvider, initReactI18next } from 'react-i18next';\n\nimport { type Translator, TranslatorProvider } from '../i18n/i18n-context.js';\n\n/**\n * The i18next binding of the translator port.\n *\n * Behind a subpath, with `i18next`, `react-i18next` and `@entifix/i18n` as\n * optional peers, so the controls themselves stay adoptable without any of it.\n * Package-level dependencies are not per-subpath — the optional peers are what\n * does the work, the same arrangement as `@entifix/mongo/transactions`.\n */\nconst translatorFor = (instance: I18nInstance, locale: Locale): Translator => ({\n  locale,\n  formatters: makeFormatters(locale),\n  // `Translator.t` takes a plain string, because the port has to be\n  // implementable without i18next at all. i18next's own `Namespace` is whatever\n  // union the host declared, and it is not this adapter's job to know it — the\n  // key stays checked at the `useT('shell')` call site, where the augmentation\n  // is in scope.\n  t: (ns, key, params) => {\n    const fixed = instance.getFixedT(\n      locale,\n      (ns ?? null) as Parameters<I18nInstance['getFixedT']>[1],\n    ) as (key: string, params?: Record<string, unknown>) => string;\n    return fixed(key, params);\n  },\n});\n\nexport interface I18nProviderProps extends PropsWithChildren {\n  /** Negotiated upstream — by the Next middleware in an app, by a decorator in Storybook. */\n  locale: Locale;\n}\n\n/**\n * Binds one locale to the subtree. A fresh i18next instance per locale keeps\n * concurrent server renders from sharing mutable `lng` state; `I18nextProvider`\n * carries it so any nested `useTranslation` resolves against the same catalogs.\n */\nexport function I18nProvider({ locale, children }: I18nProviderProps) {\n  const instance = useMemo(\n    () => createI18n(locale, [initReactI18next]),\n    [locale],\n  );\n  const translator = useMemo(\n    () => translatorFor(instance, locale),\n    [instance, locale],\n  );\n\n  return (\n    <TranslatorProvider translator={translator}>\n      <I18nextProvider i18n={instance}>{children}</I18nextProvider>\n    </TranslatorProvider>\n  );\n}\n\n/**\n * A translator over the shared fallback instance, for a caller that has\n * catalogs installed but no provider in the tree — a spec, a Storybook\n * decorator that renders one control.\n */\nexport function fallbackI18nextTranslator(locale: Locale): Translator {\n  return translatorFor(sharedFallbackI18n([initReactI18next]), locale);\n}\n"],"names":["makeFormatters","createI18n","sharedFallbackI18n","useMemo","I18nextProvider","initReactI18next","TranslatorProvider","translatorFor","instance","locale","formatters","t","ns","key","params","fixed","getFixedT","I18nProvider","children","translator","i18n","fallbackI18nextTranslator"],"mappings":"AAAA;;AAEA,SAAsBA,cAAc,QAAQ,gBAAgB;AAC5D,SAASC,UAAU,EAAEC,kBAAkB,QAAQ,gBAAgB;AAE/D,SAAiCC,OAAO,QAAQ,QAAQ;AACxD,SAASC,eAAe,EAAEC,gBAAgB,QAAQ,gBAAgB;AAElE,SAA0BC,kBAAkB,QAAQ,0BAA0B;AAE9E;;;;;;;CAOC,GACD,MAAMC,gBAAgB,CAACC,UAAwBC,SAAgC,CAAA;QAC7EA;QACAC,YAAYV,eAAeS;QAC3B,kEAAkE;QAClE,8EAA8E;QAC9E,6EAA6E;QAC7E,6EAA6E;QAC7E,eAAe;QACfE,GAAG,CAACC,IAAIC,KAAKC;YACX,MAAMC,QAAQP,SAASQ,SAAS,CAC9BP,QACCG,aAAAA,KAAM;YAET,OAAOG,MAAMF,KAAKC;QACpB;IACF,CAAA;AAOA;;;;CAIC,GACD,OAAO,SAASG,aAAa,EAAER,MAAM,EAAES,QAAQ,EAAqB;IAClE,MAAMV,WAAWL,QACf,IAAMF,WAAWQ,QAAQ;YAACJ;SAAiB,GAC3C;QAACI;KAAO;IAEV,MAAMU,aAAahB,QACjB,IAAMI,cAAcC,UAAUC,SAC9B;QAACD;QAAUC;KAAO;IAGpB,qBACE,KAACH;QAAmBa,YAAYA;kBAC9B,cAAA,KAACf;YAAgBgB,MAAMZ;sBAAWU;;;AAGxC;AAEA;;;;CAIC,GACD,OAAO,SAASG,0BAA0BZ,MAAc;IACtD,OAAOF,cAAcL,mBAAmB;QAACG;KAAiB,GAAGI;AAC/D"}

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+export * from './i18n/index.js';
+export * from './preferences/index.js';
+export * from './theme/index.js';
+export * from './ui/actions/index.js';
+export * from './ui/atoms/button/index.js';
+export * from './ui/atoms/cell-value/index.js';
+export * from './ui/atoms/field/index.js';
+export * from './ui/atoms/field-control/index.js';
+export * from './ui/atoms/skeleton/index.js';
+export * from './ui/atoms/table/index.js';
+export * from './ui/atoms/text/index.js';
+export * from './ui/layout/box/index.js';
+export * from './ui/layout/center/index.js';
+export * from './ui/layout/cluster/index.js';
+export * from './ui/layout/cover/index.js';
+export * from './ui/layout/grid/index.js';
+export * from './ui/layout/sidebar/index.js';
+export * from './ui/layout/switcher/index.js';
+export * from './ui/molecules/breadcrumbs/index.js';
+export * from './ui/molecules/bulk-action-bar/index.js';
+export * from './ui/molecules/bulk-result/index.js';
+export * from './ui/molecules/card/index.js';
+export * from './ui/molecules/column-settings/index.js';
+export * from './ui/molecules/confirm-dialog/index.js';
+export * from './ui/molecules/drawer/index.js';
+export * from './ui/molecules/entity-link-input/index.js';
+export * from './ui/molecules/entity-link-picker/index.js';
+export * from './ui/molecules/entity-record-card/index.js';
+export * from './ui/molecules/filter-builder/index.js';
+export * from './ui/molecules/loading-boundary/index.js';
+export * from './ui/molecules/menu/index.js';
+export * from './ui/molecules/pagination/index.js';
+export * from './ui/molecules/sort-builder/index.js';
+export * from './ui/molecules/stack/index.js';
+export * from './ui/molecules/tab-strip/index.js';
+export * from './ui/molecules/table-toolbar/index.js';
+export * from './ui/molecules/theme-switcher/index.js';
+export * from './ui/organisms/command-palette/index.js';
+export * from './ui/organisms/entity-detail-grid/index.js';
+export * from './ui/organisms/entity-form/index.js';
+export * from './ui/organisms/entity-table/index.js';
+export * from './ui/organisms/top-bar/index.js';
+export * from './ui/organisms/wizard/index.js';
+export * from './ui/utils/cn.js';
+export * from './ui/utils/use-hotkey.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,cAAc,wCAAwC,CAAC;AACvD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC;AACrD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,47 @@
+export * from './i18n/index.js';
+export * from './preferences/index.js';
+export * from './theme/index.js';
+export * from './ui/actions/index.js';
+export * from './ui/atoms/button/index.js';
+export * from './ui/atoms/cell-value/index.js';
+export * from './ui/atoms/field/index.js';
+export * from './ui/atoms/field-control/index.js';
+export * from './ui/atoms/skeleton/index.js';
+export * from './ui/atoms/table/index.js';
+export * from './ui/atoms/text/index.js';
+export * from './ui/layout/box/index.js';
+export * from './ui/layout/center/index.js';
+export * from './ui/layout/cluster/index.js';
+export * from './ui/layout/cover/index.js';
+export * from './ui/layout/grid/index.js';
+export * from './ui/layout/sidebar/index.js';
+export * from './ui/layout/switcher/index.js';
+export * from './ui/molecules/breadcrumbs/index.js';
+export * from './ui/molecules/bulk-action-bar/index.js';
+export * from './ui/molecules/bulk-result/index.js';
+export * from './ui/molecules/card/index.js';
+export * from './ui/molecules/column-settings/index.js';
+export * from './ui/molecules/confirm-dialog/index.js';
+export * from './ui/molecules/drawer/index.js';
+export * from './ui/molecules/entity-link-input/index.js';
+export * from './ui/molecules/entity-link-picker/index.js';
+export * from './ui/molecules/entity-record-card/index.js';
+export * from './ui/molecules/filter-builder/index.js';
+export * from './ui/molecules/loading-boundary/index.js';
+export * from './ui/molecules/menu/index.js';
+export * from './ui/molecules/pagination/index.js';
+export * from './ui/molecules/sort-builder/index.js';
+export * from './ui/molecules/stack/index.js';
+export * from './ui/molecules/tab-strip/index.js';
+export * from './ui/molecules/table-toolbar/index.js';
+export * from './ui/molecules/theme-switcher/index.js';
+export * from './ui/organisms/command-palette/index.js';
+export * from './ui/organisms/entity-detail-grid/index.js';
+export * from './ui/organisms/entity-form/index.js';
+export * from './ui/organisms/entity-table/index.js';
+export * from './ui/organisms/top-bar/index.js';
+export * from './ui/organisms/wizard/index.js';
+export * from './ui/utils/cn.js';
+export * from './ui/utils/use-hotkey.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './i18n/index.js';\nexport * from './preferences/index.js';\nexport * from './theme/index.js';\nexport * from './ui/actions/index.js';\nexport * from './ui/atoms/button/index.js';\nexport * from './ui/atoms/cell-value/index.js';\nexport * from './ui/atoms/field/index.js';\nexport * from './ui/atoms/field-control/index.js';\nexport * from './ui/atoms/skeleton/index.js';\nexport * from './ui/atoms/table/index.js';\nexport * from './ui/atoms/text/index.js';\nexport * from './ui/layout/box/index.js';\nexport * from './ui/layout/center/index.js';\nexport * from './ui/layout/cluster/index.js';\nexport * from './ui/layout/cover/index.js';\nexport * from './ui/layout/grid/index.js';\nexport * from './ui/layout/sidebar/index.js';\nexport * from './ui/layout/switcher/index.js';\nexport * from './ui/molecules/breadcrumbs/index.js';\nexport * from './ui/molecules/bulk-action-bar/index.js';\nexport * from './ui/molecules/bulk-result/index.js';\nexport * from './ui/molecules/card/index.js';\nexport * from './ui/molecules/column-settings/index.js';\nexport * from './ui/molecules/confirm-dialog/index.js';\nexport * from './ui/molecules/drawer/index.js';\nexport * from './ui/molecules/entity-link-input/index.js';\nexport * from './ui/molecules/entity-link-picker/index.js';\nexport * from './ui/molecules/entity-record-card/index.js';\nexport * from './ui/molecules/filter-builder/index.js';\nexport * from './ui/molecules/loading-boundary/index.js';\nexport * from './ui/molecules/menu/index.js';\nexport * from './ui/molecules/pagination/index.js';\nexport * from './ui/molecules/sort-builder/index.js';\nexport * from './ui/molecules/stack/index.js';\nexport * from './ui/molecules/tab-strip/index.js';\nexport * from './ui/molecules/table-toolbar/index.js';\nexport * from './ui/molecules/theme-switcher/index.js';\nexport * from './ui/organisms/command-palette/index.js';\nexport * from './ui/organisms/entity-detail-grid/index.js';\nexport * from './ui/organisms/entity-form/index.js';\nexport * from './ui/organisms/entity-table/index.js';\nexport * from './ui/organisms/top-bar/index.js';\nexport * from './ui/organisms/wizard/index.js';\nexport * from './ui/utils/cn.js';\nexport * from './ui/utils/use-hotkey.js';\n"],"names":[],"mappings":"AAAA,cAAc,kBAAkB;AAChC,cAAc,yBAAyB;AACvC,cAAc,mBAAmB;AACjC,cAAc,wBAAwB;AACtC,cAAc,6BAA6B;AAC3C,cAAc,iCAAiC;AAC/C,cAAc,4BAA4B;AAC1C,cAAc,oCAAoC;AAClD,cAAc,+BAA+B;AAC7C,cAAc,4BAA4B;AAC1C,cAAc,2BAA2B;AACzC,cAAc,2BAA2B;AACzC,cAAc,8BAA8B;AAC5C,cAAc,+BAA+B;AAC7C,cAAc,6BAA6B;AAC3C,cAAc,4BAA4B;AAC1C,cAAc,+BAA+B;AAC7C,cAAc,gCAAgC;AAC9C,cAAc,sCAAsC;AACpD,cAAc,0CAA0C;AACxD,cAAc,sCAAsC;AACpD,cAAc,+BAA+B;AAC7C,cAAc,0CAA0C;AACxD,cAAc,yCAAyC;AACvD,cAAc,iCAAiC;AAC/C,cAAc,4CAA4C;AAC1D,cAAc,6CAA6C;AAC3D,cAAc,6CAA6C;AAC3D,cAAc,yCAAyC;AACvD,cAAc,2CAA2C;AACzD,cAAc,+BAA+B;AAC7C,cAAc,qCAAqC;AACnD,cAAc,uCAAuC;AACrD,cAAc,gCAAgC;AAC9C,cAAc,oCAAoC;AAClD,cAAc,wCAAwC;AACtD,cAAc,yCAAyC;AACvD,cAAc,0CAA0C;AACxD,cAAc,6CAA6C;AAC3D,cAAc,sCAAsC;AACpD,cAAc,uCAAuC;AACrD,cAAc,kCAAkC;AAChD,cAAc,iCAAiC;AAC/C,cAAc,mBAAmB;AACjC,cAAc,2BAA2B"}

package/dist/preferences/index.d.ts

@@ -0,0 +1,7 @@
+export * from './indexeddb-ui-preferences-state.js';
+export * from './local-storage-ui-preferences-state.js';
+export * from './ui-preferences-context.js';
+export * from './ui-preferences-state.js';
+export * from './use-ui-preference.js';
+export * from './use-viewport-mode.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/preferences/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/preferences/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}

package/dist/preferences/index.js

@@ -0,0 +1,8 @@
+export * from './indexeddb-ui-preferences-state.js';
+export * from './local-storage-ui-preferences-state.js';
+export * from './ui-preferences-context.js';
+export * from './ui-preferences-state.js';
+export * from './use-ui-preference.js';
+export * from './use-viewport-mode.js';
+
+//# sourceMappingURL=index.js.map

package/dist/preferences/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preferences/index.ts"],"sourcesContent":["export * from './indexeddb-ui-preferences-state.js';\nexport * from './local-storage-ui-preferences-state.js';\nexport * from './ui-preferences-context.js';\nexport * from './ui-preferences-state.js';\nexport * from './use-ui-preference.js';\nexport * from './use-viewport-mode.js';\n"],"names":[],"mappings":"AAAA,cAAc,sCAAsC;AACpD,cAAc,0CAA0C;AACxD,cAAc,8BAA8B;AAC5C,cAAc,4BAA4B;AAC1C,cAAc,yBAAyB;AACvC,cAAc,yBAAyB"}

package/dist/preferences/indexeddb-ui-preferences-state.d.ts

@@ -0,0 +1,16 @@
+import { Layer } from 'effect';
+import { type UiPreferencesState, UiPreferencesStateTag } from './ui-preferences-state.js';
+/**
+ * `IndexedDB`-backed {@link UiPreferencesState} — the persistence seam for all
+ * client UI state (column layout, sidebar collapse, and now the tab workspace),
+ * unifying it with the tab/draft stores in one datastore instead of splitting
+ * between `localStorage` and IndexedDB.
+ *
+ * The port is unchanged: every method closes over the namespace, so each is
+ * `R = never`. Values are stored via structured clone (no JSON round-trip), and
+ * a failed I/O surfaces as an {@link EntifixConnError} the caller can fall back
+ * from — a stale view should degrade to defaults, not break.
+ */
+export declare function makeIndexedDbUiPreferencesState(namespace?: string): UiPreferencesState;
+export declare const IndexedDbUiPreferencesLayer: Layer.Layer<UiPreferencesStateTag, never, never>;
+//# sourceMappingURL=indexeddb-ui-preferences-state.d.ts.map

package/dist/preferences/indexeddb-ui-preferences-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexeddb-ui-preferences-state.d.ts","sourceRoot":"","sources":["../../src/preferences/indexeddb-ui-preferences-state.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AAIvC,OAAO,EACL,KAAK,kBAAkB,EACvB,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAUnC;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,GAAE,MAAyC,GACnD,kBAAkB,CA8CpB;AAED,eAAO,MAAM,2BAA2B,kDAGvC,CAAC"}

package/dist/preferences/indexeddb-ui-preferences-state.js

@@ -0,0 +1,50 @@
+import { EntifixConnError } from '@entifix/core';
+import { Effect, Layer } from 'effect';
+import { openDB } from 'idb';
+import { DEFAULT_UI_PREFERENCES_NAMESPACE } from './local-storage-ui-preferences-state.js';
+import { UiPreferencesStateTag } from './ui-preferences-state.js';
+const DB_NAME = 'entifix-ui-preferences';
+const STORE_NAME = 'preferences';
+/** No IndexedDB during SSR — reads resolve empty and writes are dropped. */ function hasIndexedDb() {
+    return typeof indexedDB !== 'undefined';
+}
+/**
+ * `IndexedDB`-backed {@link UiPreferencesState} — the persistence seam for all
+ * client UI state (column layout, sidebar collapse, and now the tab workspace),
+ * unifying it with the tab/draft stores in one datastore instead of splitting
+ * between `localStorage` and IndexedDB.
+ *
+ * The port is unchanged: every method closes over the namespace, so each is
+ * `R = never`. Values are stored via structured clone (no JSON round-trip), and
+ * a failed I/O surfaces as an {@link EntifixConnError} the caller can fall back
+ * from — a stale view should degrade to defaults, not break.
+ */ export function makeIndexedDbUiPreferencesState(namespace = DEFAULT_UI_PREFERENCES_NAMESPACE) {
+    const storageKey = (key)=>`${namespace}:${key}`;
+    let database;
+    const open = ()=>database != null ? database : database = openDB(DB_NAME, 1, {
+            upgrade (db) {
+                db.createObjectStore(STORE_NAME);
+            }
+        });
+    const io = (action, key, run)=>Effect.tryPromise({
+            try: run,
+            catch: (cause)=>new EntifixConnError(`Unable to ${action} UI preference "${key}"`, cause)
+        });
+    return {
+        read: (key)=>io('read', key, async ()=>{
+                if (!hasIndexedDb()) return undefined;
+                return (await open()).get(STORE_NAME, storageKey(key));
+            }),
+        write: (key, value)=>io('write', key, async ()=>{
+                if (!hasIndexedDb()) return;
+                await (await open()).put(STORE_NAME, value, storageKey(key));
+            }),
+        remove: (key)=>io('remove', key, async ()=>{
+                if (!hasIndexedDb()) return;
+                await (await open()).delete(STORE_NAME, storageKey(key));
+            })
+    };
+}
+export const IndexedDbUiPreferencesLayer = Layer.succeed(UiPreferencesStateTag, makeIndexedDbUiPreferencesState());
+
+//# sourceMappingURL=indexeddb-ui-preferences-state.js.map

package/dist/preferences/indexeddb-ui-preferences-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preferences/indexeddb-ui-preferences-state.ts"],"sourcesContent":["import { EntifixConnError, type EntifixError } from '@entifix/core';\nimport { Effect, Layer } from 'effect';\nimport { type IDBPDatabase, openDB } from 'idb';\n\nimport { DEFAULT_UI_PREFERENCES_NAMESPACE } from './local-storage-ui-preferences-state.js';\nimport {\n  type UiPreferencesState,\n  UiPreferencesStateTag,\n} from './ui-preferences-state.js';\n\nconst DB_NAME = 'entifix-ui-preferences';\nconst STORE_NAME = 'preferences';\n\n/** No IndexedDB during SSR — reads resolve empty and writes are dropped. */\nfunction hasIndexedDb(): boolean {\n  return typeof indexedDB !== 'undefined';\n}\n\n/**\n * `IndexedDB`-backed {@link UiPreferencesState} — the persistence seam for all\n * client UI state (column layout, sidebar collapse, and now the tab workspace),\n * unifying it with the tab/draft stores in one datastore instead of splitting\n * between `localStorage` and IndexedDB.\n *\n * The port is unchanged: every method closes over the namespace, so each is\n * `R = never`. Values are stored via structured clone (no JSON round-trip), and\n * a failed I/O surfaces as an {@link EntifixConnError} the caller can fall back\n * from — a stale view should degrade to defaults, not break.\n */\nexport function makeIndexedDbUiPreferencesState(\n  namespace: string = DEFAULT_UI_PREFERENCES_NAMESPACE,\n): UiPreferencesState {\n  const storageKey = (key: string) => `${namespace}:${key}`;\n\n  let database: Promise<IDBPDatabase> | undefined;\n  const open = () =>\n    (database ??= openDB(DB_NAME, 1, {\n      upgrade(db) {\n        db.createObjectStore(STORE_NAME);\n      },\n    }));\n\n  const io = <TValue>(\n    action: string,\n    key: string,\n    run: () => Promise<TValue>,\n  ): Effect.Effect<TValue, EntifixError> =>\n    Effect.tryPromise({\n      try: run,\n      catch: cause =>\n        new EntifixConnError(\n          `Unable to ${action} UI preference \"${key}\"`,\n          cause,\n        ) as EntifixError,\n    });\n\n  return {\n    read: <TValue>(key: string) =>\n      io<TValue | undefined>('read', key, async () => {\n        if (!hasIndexedDb()) return undefined;\n        return (await open()).get(STORE_NAME, storageKey(key)) as Promise<\n          TValue | undefined\n        >;\n      }),\n\n    write: <TValue>(key: string, value: TValue) =>\n      io<void>('write', key, async () => {\n        if (!hasIndexedDb()) return;\n        await (await open()).put(STORE_NAME, value, storageKey(key));\n      }),\n\n    remove: (key: string) =>\n      io<void>('remove', key, async () => {\n        if (!hasIndexedDb()) return;\n        await (await open()).delete(STORE_NAME, storageKey(key));\n      }),\n  };\n}\n\nexport const IndexedDbUiPreferencesLayer = Layer.succeed(\n  UiPreferencesStateTag,\n  makeIndexedDbUiPreferencesState(),\n);\n"],"names":["EntifixConnError","Effect","Layer","openDB","DEFAULT_UI_PREFERENCES_NAMESPACE","UiPreferencesStateTag","DB_NAME","STORE_NAME","hasIndexedDb","indexedDB","makeIndexedDbUiPreferencesState","namespace","storageKey","key","database","open","upgrade","db","createObjectStore","io","action","run","tryPromise","try","catch","cause","read","undefined","get","write","value","put","remove","delete","IndexedDbUiPreferencesLayer","succeed"],"mappings":"AAAA,SAASA,gBAAgB,QAA2B,gBAAgB;AACpE,SAASC,MAAM,EAAEC,KAAK,QAAQ,SAAS;AACvC,SAA4BC,MAAM,QAAQ,MAAM;AAEhD,SAASC,gCAAgC,QAAQ,0CAA0C;AAC3F,SAEEC,qBAAqB,QAChB,4BAA4B;AAEnC,MAAMC,UAAU;AAChB,MAAMC,aAAa;AAEnB,0EAA0E,GAC1E,SAASC;IACP,OAAO,OAAOC,cAAc;AAC9B;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASC,gCACdC,YAAoBP,gCAAgC;IAEpD,MAAMQ,aAAa,CAACC,MAAgB,GAAGF,UAAU,CAAC,EAAEE,KAAK;IAEzD,IAAIC;IACJ,MAAMC,OAAO,IACVD,mBAAAA,WAAAA,WAAaX,OAAOG,SAAS,GAAG;YAC/BU,SAAQC,EAAE;gBACRA,GAAGC,iBAAiB,CAACX;YACvB;QACF;IAEF,MAAMY,KAAK,CACTC,QACAP,KACAQ,MAEApB,OAAOqB,UAAU,CAAC;YAChBC,KAAKF;YACLG,OAAOC,CAAAA,QACL,IAAIzB,iBACF,CAAC,UAAU,EAAEoB,OAAO,gBAAgB,EAAEP,IAAI,CAAC,CAAC,EAC5CY;QAEN;IAEF,OAAO;QACLC,MAAM,CAASb,MACbM,GAAuB,QAAQN,KAAK;gBAClC,IAAI,CAACL,gBAAgB,OAAOmB;gBAC5B,OAAO,AAAC,CAAA,MAAMZ,MAAK,EAAGa,GAAG,CAACrB,YAAYK,WAAWC;YAGnD;QAEFgB,OAAO,CAAShB,KAAaiB,QAC3BX,GAAS,SAASN,KAAK;gBACrB,IAAI,CAACL,gBAAgB;gBACrB,MAAM,AAAC,CAAA,MAAMO,MAAK,EAAGgB,GAAG,CAACxB,YAAYuB,OAAOlB,WAAWC;YACzD;QAEFmB,QAAQ,CAACnB,MACPM,GAAS,UAAUN,KAAK;gBACtB,IAAI,CAACL,gBAAgB;gBACrB,MAAM,AAAC,CAAA,MAAMO,MAAK,EAAGkB,MAAM,CAAC1B,YAAYK,WAAWC;YACrD;IACJ;AACF;AAEA,OAAO,MAAMqB,8BAA8BhC,MAAMiC,OAAO,CACtD9B,uBACAK,mCACA"}

package/dist/preferences/local-storage-ui-preferences-state.d.ts

@@ -0,0 +1,16 @@
+import { Layer } from 'effect';
+import { type UiPreferencesState, UiPreferencesStateTag } from './ui-preferences-state.js';
+export declare const DEFAULT_UI_PREFERENCES_NAMESPACE = "entifix-ui";
+/**
+ * `localStorage`-backed {@link UiPreferencesState}. Every method closes over the
+ * namespace, so each one is `R = never` and the object satisfies the interface
+ * without leaking a requirement into callers (the same shape
+ * `makeMongoRepository` uses).
+ *
+ * Values are JSON-encoded. Unparseable entries resolve to `undefined` rather
+ * than failing: a stale or hand-edited key should fall back to defaults, not
+ * break the view.
+ */
+export declare function makeLocalStorageUiPreferencesState(namespace?: string): UiPreferencesState;
+export declare const LocalStorageUiPreferencesLayer: Layer.Layer<UiPreferencesStateTag, never, never>;
+//# sourceMappingURL=local-storage-ui-preferences-state.d.ts.map

package/dist/preferences/local-storage-ui-preferences-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage-ui-preferences-state.d.ts","sourceRoot":"","sources":["../../src/preferences/local-storage-ui-preferences-state.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,EACL,KAAK,kBAAkB,EACvB,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAEnC,eAAO,MAAM,gCAAgC,eAAe,CAAC;AAO7D;;;;;;;;;GASG;AACH,wBAAgB,kCAAkC,CAChD,SAAS,GAAE,MAAyC,GACnD,kBAAkB,CAiDpB;AAED,eAAO,MAAM,8BAA8B,kDAG1C,CAAC"}

package/dist/preferences/local-storage-ui-preferences-state.js

@@ -0,0 +1,51 @@
+import { EntifixConnError } from '@entifix/core';
+import { Effect, Layer } from 'effect';
+import { UiPreferencesStateTag } from './ui-preferences-state.js';
+export const DEFAULT_UI_PREFERENCES_NAMESPACE = 'entifix-ui';
+/** No `window` during SSR — reads resolve empty and writes are dropped. */ function isBrowser() {
+    return typeof window !== 'undefined' && !!window.localStorage;
+}
+/**
+ * `localStorage`-backed {@link UiPreferencesState}. Every method closes over the
+ * namespace, so each one is `R = never` and the object satisfies the interface
+ * without leaking a requirement into callers (the same shape
+ * `makeMongoRepository` uses).
+ *
+ * Values are JSON-encoded. Unparseable entries resolve to `undefined` rather
+ * than failing: a stale or hand-edited key should fall back to defaults, not
+ * break the view.
+ */ export function makeLocalStorageUiPreferencesState(namespace = DEFAULT_UI_PREFERENCES_NAMESPACE) {
+    const storageKey = (key)=>`${namespace}:${key}`;
+    return {
+        read: (key)=>Effect.try({
+                try: ()=>{
+                    if (!isBrowser()) return undefined;
+                    const raw = window.localStorage.getItem(storageKey(key));
+                    if (raw === null) return undefined;
+                    try {
+                        return JSON.parse(raw);
+                    } catch (unused) {
+                        return undefined;
+                    }
+                },
+                catch: (cause)=>new EntifixConnError(`Unable to read UI preference "${key}"`, cause)
+            }),
+        write: (key, value)=>Effect.try({
+                try: ()=>{
+                    if (!isBrowser()) return;
+                    window.localStorage.setItem(storageKey(key), JSON.stringify(value));
+                },
+                catch: (cause)=>new EntifixConnError(`Unable to write UI preference "${key}"`, cause)
+            }),
+        remove: (key)=>Effect.try({
+                try: ()=>{
+                    if (!isBrowser()) return;
+                    window.localStorage.removeItem(storageKey(key));
+                },
+                catch: (cause)=>new EntifixConnError(`Unable to remove UI preference "${key}"`, cause)
+            })
+    };
+}
+export const LocalStorageUiPreferencesLayer = Layer.succeed(UiPreferencesStateTag, makeLocalStorageUiPreferencesState());
+
+//# sourceMappingURL=local-storage-ui-preferences-state.js.map

package/dist/preferences/local-storage-ui-preferences-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preferences/local-storage-ui-preferences-state.ts"],"sourcesContent":["import { EntifixConnError } from '@entifix/core';\nimport { Effect, Layer } from 'effect';\n\nimport {\n  type UiPreferencesState,\n  UiPreferencesStateTag,\n} from './ui-preferences-state.js';\n\nexport const DEFAULT_UI_PREFERENCES_NAMESPACE = 'entifix-ui';\n\n/** No `window` during SSR — reads resolve empty and writes are dropped. */\nfunction isBrowser(): boolean {\n  return typeof window !== 'undefined' && !!window.localStorage;\n}\n\n/**\n * `localStorage`-backed {@link UiPreferencesState}. Every method closes over the\n * namespace, so each one is `R = never` and the object satisfies the interface\n * without leaking a requirement into callers (the same shape\n * `makeMongoRepository` uses).\n *\n * Values are JSON-encoded. Unparseable entries resolve to `undefined` rather\n * than failing: a stale or hand-edited key should fall back to defaults, not\n * break the view.\n */\nexport function makeLocalStorageUiPreferencesState(\n  namespace: string = DEFAULT_UI_PREFERENCES_NAMESPACE,\n): UiPreferencesState {\n  const storageKey = (key: string) => `${namespace}:${key}`;\n\n  return {\n    read: <TValue>(key: string) =>\n      Effect.try({\n        try: () => {\n          if (!isBrowser()) return undefined;\n          const raw = window.localStorage.getItem(storageKey(key));\n          if (raw === null) return undefined;\n          try {\n            return JSON.parse(raw) as TValue;\n          } catch {\n            return undefined;\n          }\n        },\n        catch: cause =>\n          new EntifixConnError(\n            `Unable to read UI preference \"${key}\"`,\n            cause,\n          ) as EntifixConnError,\n      }),\n\n    write: <TValue>(key: string, value: TValue) =>\n      Effect.try({\n        try: () => {\n          if (!isBrowser()) return;\n          window.localStorage.setItem(storageKey(key), JSON.stringify(value));\n        },\n        catch: cause =>\n          new EntifixConnError(\n            `Unable to write UI preference \"${key}\"`,\n            cause,\n          ) as EntifixConnError,\n      }),\n\n    remove: (key: string) =>\n      Effect.try({\n        try: () => {\n          if (!isBrowser()) return;\n          window.localStorage.removeItem(storageKey(key));\n        },\n        catch: cause =>\n          new EntifixConnError(\n            `Unable to remove UI preference \"${key}\"`,\n            cause,\n          ) as EntifixConnError,\n      }),\n  };\n}\n\nexport const LocalStorageUiPreferencesLayer = Layer.succeed(\n  UiPreferencesStateTag,\n  makeLocalStorageUiPreferencesState(),\n);\n"],"names":["EntifixConnError","Effect","Layer","UiPreferencesStateTag","DEFAULT_UI_PREFERENCES_NAMESPACE","isBrowser","window","localStorage","makeLocalStorageUiPreferencesState","namespace","storageKey","key","read","try","undefined","raw","getItem","JSON","parse","catch","cause","write","value","setItem","stringify","remove","removeItem","LocalStorageUiPreferencesLayer","succeed"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,gBAAgB;AACjD,SAASC,MAAM,EAAEC,KAAK,QAAQ,SAAS;AAEvC,SAEEC,qBAAqB,QAChB,4BAA4B;AAEnC,OAAO,MAAMC,mCAAmC,aAAa;AAE7D,yEAAyE,GACzE,SAASC;IACP,OAAO,OAAOC,WAAW,eAAe,CAAC,CAACA,OAAOC,YAAY;AAC/D;AAEA;;;;;;;;;CASC,GACD,OAAO,SAASC,mCACdC,YAAoBL,gCAAgC;IAEpD,MAAMM,aAAa,CAACC,MAAgB,GAAGF,UAAU,CAAC,EAAEE,KAAK;IAEzD,OAAO;QACLC,MAAM,CAASD,MACbV,OAAOY,GAAG,CAAC;gBACTA,KAAK;oBACH,IAAI,CAACR,aAAa,OAAOS;oBACzB,MAAMC,MAAMT,OAAOC,YAAY,CAACS,OAAO,CAACN,WAAWC;oBACnD,IAAII,QAAQ,MAAM,OAAOD;oBACzB,IAAI;wBACF,OAAOG,KAAKC,KAAK,CAACH;oBACpB,EAAE,eAAM;wBACN,OAAOD;oBACT;gBACF;gBACAK,OAAOC,CAAAA,QACL,IAAIpB,iBACF,CAAC,8BAA8B,EAAEW,IAAI,CAAC,CAAC,EACvCS;YAEN;QAEFC,OAAO,CAASV,KAAaW,QAC3BrB,OAAOY,GAAG,CAAC;gBACTA,KAAK;oBACH,IAAI,CAACR,aAAa;oBAClBC,OAAOC,YAAY,CAACgB,OAAO,CAACb,WAAWC,MAAMM,KAAKO,SAAS,CAACF;gBAC9D;gBACAH,OAAOC,CAAAA,QACL,IAAIpB,iBACF,CAAC,+BAA+B,EAAEW,IAAI,CAAC,CAAC,EACxCS;YAEN;QAEFK,QAAQ,CAACd,MACPV,OAAOY,GAAG,CAAC;gBACTA,KAAK;oBACH,IAAI,CAACR,aAAa;oBAClBC,OAAOC,YAAY,CAACmB,UAAU,CAAChB,WAAWC;gBAC5C;gBACAQ,OAAOC,CAAAA,QACL,IAAIpB,iBACF,CAAC,gCAAgC,EAAEW,IAAI,CAAC,CAAC,EACzCS;YAEN;IACJ;AACF;AAEA,OAAO,MAAMO,iCAAiCzB,MAAM0B,OAAO,CACzDzB,uBACAK,sCACA"}

package/dist/preferences/ui-preferences-context.d.ts

@@ -0,0 +1,16 @@
+import { type PropsWithChildren } from 'react';
+import type { UiPreferencesState } from './ui-preferences-state.js';
+export interface UiPreferencesProviderProps extends PropsWithChildren {
+    /** Explicit store. Omit and a `localStorage` one is built from `namespace`. */
+    store?: UiPreferencesState;
+    /** Key prefix, so apps sharing an origin don't clobber each other. */
+    namespace?: string;
+}
+/**
+ * Supplies the {@link UiPreferencesState} every personalizable control reads
+ * through. Mount it once per app, at the root: swapping the implementation here
+ * (say, for a server-backed store) migrates every control at once.
+ */
+export declare function UiPreferencesProvider({ children, store, namespace, }: UiPreferencesProviderProps): import("react").JSX.Element;
+export declare function useUiPreferencesState(): UiPreferencesState;
+//# sourceMappingURL=ui-preferences-context.d.ts.map

package/dist/preferences/ui-preferences-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-preferences-context.d.ts","sourceRoot":"","sources":["../../src/preferences/ui-preferences-context.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,iBAAiB,EAGvB,MAAM,OAAO,CAAC;AAMf,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAIpE,MAAM,WAAW,0BAA2B,SAAQ,iBAAiB;IACnE,+EAA+E;IAC/E,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,QAAQ,EACR,KAAK,EACL,SAA4C,GAC7C,EAAE,0BAA0B,+BAW5B;AAUD,wBAAgB,qBAAqB,IAAI,kBAAkB,CAE1D"}

package/dist/preferences/ui-preferences-context.js

@@ -0,0 +1,31 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { DEFAULT_UI_PREFERENCES_NAMESPACE, makeLocalStorageUiPreferencesState } from './local-storage-ui-preferences-state.js';
+const UiPreferencesContext = /*#__PURE__*/ createContext(null);
+/**
+ * Supplies the {@link UiPreferencesState} every personalizable control reads
+ * through. Mount it once per app, at the root: swapping the implementation here
+ * (say, for a server-backed store) migrates every control at once.
+ */ export function UiPreferencesProvider({ children, store, namespace = DEFAULT_UI_PREFERENCES_NAMESPACE }) {
+    const value = useMemo(()=>store != null ? store : makeLocalStorageUiPreferencesState(namespace), [
+        store,
+        namespace
+    ]);
+    return /*#__PURE__*/ _jsx(UiPreferencesContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+/**
+ * The active store. Falls back to a default `localStorage` store when no
+ * provider is mounted, so a control stays usable in isolation (tests, an app
+ * that has not opted in yet) — the fallback is module-level so its identity is
+ * stable across renders.
+ */ const fallbackStore = makeLocalStorageUiPreferencesState();
+export function useUiPreferencesState() {
+    var _useContext;
+    return (_useContext = useContext(UiPreferencesContext)) != null ? _useContext : fallbackStore;
+}
+
+//# sourceMappingURL=ui-preferences-context.js.map

package/dist/preferences/ui-preferences-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preferences/ui-preferences-context.tsx"],"sourcesContent":["'use client';\n\nimport {\n  createContext,\n  type PropsWithChildren,\n  useContext,\n  useMemo,\n} from 'react';\n\nimport {\n  DEFAULT_UI_PREFERENCES_NAMESPACE,\n  makeLocalStorageUiPreferencesState,\n} from './local-storage-ui-preferences-state.js';\nimport type { UiPreferencesState } from './ui-preferences-state.js';\n\nconst UiPreferencesContext = createContext<UiPreferencesState | null>(null);\n\nexport interface UiPreferencesProviderProps extends PropsWithChildren {\n  /** Explicit store. Omit and a `localStorage` one is built from `namespace`. */\n  store?: UiPreferencesState;\n  /** Key prefix, so apps sharing an origin don't clobber each other. */\n  namespace?: string;\n}\n\n/**\n * Supplies the {@link UiPreferencesState} every personalizable control reads\n * through. Mount it once per app, at the root: swapping the implementation here\n * (say, for a server-backed store) migrates every control at once.\n */\nexport function UiPreferencesProvider({\n  children,\n  store,\n  namespace = DEFAULT_UI_PREFERENCES_NAMESPACE,\n}: UiPreferencesProviderProps) {\n  const value = useMemo(\n    () => store ?? makeLocalStorageUiPreferencesState(namespace),\n    [store, namespace],\n  );\n\n  return (\n    <UiPreferencesContext.Provider value={value}>\n      {children}\n    </UiPreferencesContext.Provider>\n  );\n}\n\n/**\n * The active store. Falls back to a default `localStorage` store when no\n * provider is mounted, so a control stays usable in isolation (tests, an app\n * that has not opted in yet) — the fallback is module-level so its identity is\n * stable across renders.\n */\nconst fallbackStore = makeLocalStorageUiPreferencesState();\n\nexport function useUiPreferencesState(): UiPreferencesState {\n  return useContext(UiPreferencesContext) ?? fallbackStore;\n}\n"],"names":["createContext","useContext","useMemo","DEFAULT_UI_PREFERENCES_NAMESPACE","makeLocalStorageUiPreferencesState","UiPreferencesContext","UiPreferencesProvider","children","store","namespace","value","Provider","fallbackStore","useUiPreferencesState"],"mappings":"AAAA;;AAEA,SACEA,aAAa,EAEbC,UAAU,EACVC,OAAO,QACF,QAAQ;AAEf,SACEC,gCAAgC,EAChCC,kCAAkC,QAC7B,0CAA0C;AAGjD,MAAMC,qCAAuBL,cAAyC;AAStE;;;;CAIC,GACD,OAAO,SAASM,sBAAsB,EACpCC,QAAQ,EACRC,KAAK,EACLC,YAAYN,gCAAgC,EACjB;IAC3B,MAAMO,QAAQR,QACZ,IAAMM,gBAAAA,QAASJ,mCAAmCK,YAClD;QAACD;QAAOC;KAAU;IAGpB,qBACE,KAACJ,qBAAqBM,QAAQ;QAACD,OAAOA;kBACnCH;;AAGP;AAEA;;;;;CAKC,GACD,MAAMK,gBAAgBR;AAEtB,OAAO,SAASS;QACPZ;IAAP,QAAOA,cAAAA,WAAWI,iCAAXJ,cAAoCW;AAC7C"}

package/dist/preferences/ui-preferences-state.d.ts

@@ -0,0 +1,23 @@
+import type { EntifixError } from '@entifix/core';
+import { Context, type Effect } from 'effect';
+/**
+ * Where a user's UI personalization lives — column order and visibility today,
+ * any other per-user view state later.
+ *
+ * The port is Effect-returning and therefore free to be asynchronous: the
+ * shipped adapter writes to `localStorage` synchronously, but a server-backed
+ * store (per-user preferences fetched over HTTP) is a drop-in replacement that
+ * no component has to be rewritten for.
+ *
+ * Values are stored and returned as-is; adapters own their own encoding.
+ */
+export interface UiPreferencesState {
+    read<TValue>(key: string): Effect.Effect<TValue | undefined, EntifixError>;
+    write<TValue>(key: string, value: TValue): Effect.Effect<void, EntifixError>;
+    remove(key: string): Effect.Effect<void, EntifixError>;
+}
+declare const UiPreferencesStateTag_base: Context.TagClass<UiPreferencesStateTag, "UiPreferencesState", UiPreferencesState>;
+export declare class UiPreferencesStateTag extends UiPreferencesStateTag_base {
+}
+export {};
+//# sourceMappingURL=ui-preferences-state.d.ts.map

package/dist/preferences/ui-preferences-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-preferences-state.d.ts","sourceRoot":"","sources":["../../src/preferences/ui-preferences-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,SAAS,EAAE,YAAY,CAAC,CAAC;IAC3E,KAAK,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAC7E,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;CACxD;;AAED,qBAAa,qBAAsB,SAAQ,0BAGxC;CAAG"}

package/dist/preferences/ui-preferences-state.js

@@ -0,0 +1,5 @@
+import { Context } from 'effect';
+export class UiPreferencesStateTag extends Context.Tag('UiPreferencesState')() {
+}
+
+//# sourceMappingURL=ui-preferences-state.js.map

package/dist/preferences/ui-preferences-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preferences/ui-preferences-state.ts"],"sourcesContent":["import type { EntifixError } from '@entifix/core';\nimport { Context, type Effect } from 'effect';\n\n/**\n * Where a user's UI personalization lives — column order and visibility today,\n * any other per-user view state later.\n *\n * The port is Effect-returning and therefore free to be asynchronous: the\n * shipped adapter writes to `localStorage` synchronously, but a server-backed\n * store (per-user preferences fetched over HTTP) is a drop-in replacement that\n * no component has to be rewritten for.\n *\n * Values are stored and returned as-is; adapters own their own encoding.\n */\nexport interface UiPreferencesState {\n  read<TValue>(key: string): Effect.Effect<TValue | undefined, EntifixError>;\n  write<TValue>(key: string, value: TValue): Effect.Effect<void, EntifixError>;\n  remove(key: string): Effect.Effect<void, EntifixError>;\n}\n\nexport class UiPreferencesStateTag extends Context.Tag('UiPreferencesState')<\n  UiPreferencesStateTag,\n  UiPreferencesState\n>() {}\n"],"names":["Context","UiPreferencesStateTag","Tag"],"mappings":"AACA,SAASA,OAAO,QAAqB,SAAS;AAmB9C,OAAO,MAAMC,8BAA8BD,QAAQE,GAAG,CAAC;AAGlD"}

package/dist/preferences/use-ui-preference.d.ts

@@ -0,0 +1,20 @@
+export interface UseUiPreferenceResult<TValue> {
+    value: TValue;
+    setValue: (next: TValue) => void;
+    /** False until the stored value has been read; render defaults meanwhile. */
+    isReady: boolean;
+}
+/**
+ * Reads one persisted UI preference and writes it back on change.
+ *
+ * The read runs in an effect rather than during render: the store may be
+ * asynchronous and, for the `localStorage` adapter, is unavailable during SSR —
+ * so the server renders `fallback` and the client corrects after mount. Reading
+ * it while rendering would be a hydration mismatch.
+ *
+ * Writes are optimistic: local state updates immediately and the store write is
+ * fired after. A failed write only costs the persistence of that change, so it
+ * is swallowed rather than surfaced as a render error.
+ */
+export declare function useUiPreference<TValue>(key: string, fallback: TValue): UseUiPreferenceResult<TValue>;
+//# sourceMappingURL=use-ui-preference.d.ts.map

package/dist/preferences/use-ui-preference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-ui-preference.d.ts","sourceRoot":"","sources":["../../src/preferences/use-ui-preference.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,qBAAqB,CAAC,MAAM;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,6EAA6E;IAC7E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EACpC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,GACf,qBAAqB,CAAC,MAAM,CAAC,CA8C/B"}

package/dist/preferences/use-ui-preference.js

@@ -0,0 +1,72 @@
+'use client';
+import { Effect } from 'effect';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useUiPreferencesState } from './ui-preferences-context.js';
+/**
+ * Reads one persisted UI preference and writes it back on change.
+ *
+ * The read runs in an effect rather than during render: the store may be
+ * asynchronous and, for the `localStorage` adapter, is unavailable during SSR —
+ * so the server renders `fallback` and the client corrects after mount. Reading
+ * it while rendering would be a hydration mismatch.
+ *
+ * Writes are optimistic: local state updates immediately and the store write is
+ * fired after. A failed write only costs the persistence of that change, so it
+ * is swallowed rather than surfaced as a render error.
+ */ export function useUiPreference(key, fallback) {
+    const store = useUiPreferencesState();
+    // Value and the key it belongs to are one state: readiness is then derived
+    // rather than reset in the effect, so switching `key` reports "not ready"
+    // for the new key without a synchronous setState cascading a render.
+    const [state, setState] = useState({
+        value: fallback
+    });
+    // Callers build `fallback` inline, so it is a fresh object every render.
+    // Keying the read effect on it would re-read (and clobber local edits) on
+    // every render; the ref keeps the latest without entering the dependencies.
+    const fallbackRef = useRef(fallback);
+    useEffect(()=>{
+        fallbackRef.current = fallback;
+    });
+    useEffect(()=>{
+        let active = true;
+        Effect.runPromise(store.read(key)).then((stored)=>{
+            if (!active) return;
+            setState({
+                loadedKey: key,
+                value: stored != null ? stored : fallbackRef.current
+            });
+        }).catch(()=>{
+            if (!active) return;
+            setState({
+                loadedKey: key,
+                value: fallbackRef.current
+            });
+        });
+        return ()=>{
+            active = false;
+        };
+    }, [
+        store,
+        key
+    ]);
+    const setValue = useCallback((next)=>{
+        setState({
+            loadedKey: key,
+            value: next
+        });
+        Effect.runPromise(store.write(key, next)).catch(()=>{
+        // Persistence is best-effort; the in-memory change already applied.
+        });
+    }, [
+        store,
+        key
+    ]);
+    return {
+        value: state.value,
+        setValue,
+        isReady: state.loadedKey === key
+    };
+}
+
+//# sourceMappingURL=use-ui-preference.js.map

package/dist/preferences/use-ui-preference.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preferences/use-ui-preference.ts"],"sourcesContent":["'use client';\n\nimport { Effect } from 'effect';\nimport { useCallback, useEffect, useRef, useState } from 'react';\n\nimport { useUiPreferencesState } from './ui-preferences-context.js';\n\nexport interface UseUiPreferenceResult<TValue> {\n  value: TValue;\n  setValue: (next: TValue) => void;\n  /** False until the stored value has been read; render defaults meanwhile. */\n  isReady: boolean;\n}\n\n/**\n * Reads one persisted UI preference and writes it back on change.\n *\n * The read runs in an effect rather than during render: the store may be\n * asynchronous and, for the `localStorage` adapter, is unavailable during SSR —\n * so the server renders `fallback` and the client corrects after mount. Reading\n * it while rendering would be a hydration mismatch.\n *\n * Writes are optimistic: local state updates immediately and the store write is\n * fired after. A failed write only costs the persistence of that change, so it\n * is swallowed rather than surfaced as a render error.\n */\nexport function useUiPreference<TValue>(\n  key: string,\n  fallback: TValue,\n): UseUiPreferenceResult<TValue> {\n  const store = useUiPreferencesState();\n  // Value and the key it belongs to are one state: readiness is then derived\n  // rather than reset in the effect, so switching `key` reports \"not ready\"\n  // for the new key without a synchronous setState cascading a render.\n  const [state, setState] = useState<{ loadedKey?: string; value: TValue }>({\n    value: fallback,\n  });\n\n  // Callers build `fallback` inline, so it is a fresh object every render.\n  // Keying the read effect on it would re-read (and clobber local edits) on\n  // every render; the ref keeps the latest without entering the dependencies.\n  const fallbackRef = useRef(fallback);\n  useEffect(() => {\n    fallbackRef.current = fallback;\n  });\n\n  useEffect(() => {\n    let active = true;\n\n    Effect.runPromise(store.read<TValue>(key))\n      .then(stored => {\n        if (!active) return;\n        setState({ loadedKey: key, value: stored ?? fallbackRef.current });\n      })\n      .catch(() => {\n        if (!active) return;\n        setState({ loadedKey: key, value: fallbackRef.current });\n      });\n\n    return () => {\n      active = false;\n    };\n  }, [store, key]);\n\n  const setValue = useCallback(\n    (next: TValue) => {\n      setState({ loadedKey: key, value: next });\n      Effect.runPromise(store.write(key, next)).catch(() => {\n        // Persistence is best-effort; the in-memory change already applied.\n      });\n    },\n    [store, key],\n  );\n\n  return { value: state.value, setValue, isReady: state.loadedKey === key };\n}\n"],"names":["Effect","useCallback","useEffect","useRef","useState","useUiPreferencesState","useUiPreference","key","fallback","store","state","setState","value","fallbackRef","current","active","runPromise","read","then","stored","loadedKey","catch","setValue","next","write","isReady"],"mappings":"AAAA;AAEA,SAASA,MAAM,QAAQ,SAAS;AAChC,SAASC,WAAW,EAAEC,SAAS,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,QAAQ;AAEjE,SAASC,qBAAqB,QAAQ,8BAA8B;AASpE;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,gBACdC,GAAW,EACXC,QAAgB;IAEhB,MAAMC,QAAQJ;IACd,2EAA2E;IAC3E,0EAA0E;IAC1E,qEAAqE;IACrE,MAAM,CAACK,OAAOC,SAAS,GAAGP,SAAgD;QACxEQ,OAAOJ;IACT;IAEA,yEAAyE;IACzE,0EAA0E;IAC1E,4EAA4E;IAC5E,MAAMK,cAAcV,OAAOK;IAC3BN,UAAU;QACRW,YAAYC,OAAO,GAAGN;IACxB;IAEAN,UAAU;QACR,IAAIa,SAAS;QAEbf,OAAOgB,UAAU,CAACP,MAAMQ,IAAI,CAASV,MAClCW,IAAI,CAACC,CAAAA;YACJ,IAAI,CAACJ,QAAQ;YACbJ,SAAS;gBAAES,WAAWb;gBAAKK,KAAK,EAAEO,iBAAAA,SAAUN,YAAYC,OAAO;YAAC;QAClE,GACCO,KAAK,CAAC;YACL,IAAI,CAACN,QAAQ;YACbJ,SAAS;gBAAES,WAAWb;gBAAKK,OAAOC,YAAYC,OAAO;YAAC;QACxD;QAEF,OAAO;YACLC,SAAS;QACX;IACF,GAAG;QAACN;QAAOF;KAAI;IAEf,MAAMe,WAAWrB,YACf,CAACsB;QACCZ,SAAS;YAAES,WAAWb;YAAKK,OAAOW;QAAK;QACvCvB,OAAOgB,UAAU,CAACP,MAAMe,KAAK,CAACjB,KAAKgB,OAAOF,KAAK,CAAC;QAC9C,oEAAoE;QACtE;IACF,GACA;QAACZ;QAAOF;KAAI;IAGd,OAAO;QAAEK,OAAOF,MAAME,KAAK;QAAEU;QAAUG,SAASf,MAAMU,SAAS,KAAKb;IAAI;AAC1E"}