@portnet/ui 5.0.28 → 6.0.0

package/dist/v2/personalization/index.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FAVORITES_CAPABILITY_ID", {
+  enumerable: true,
+  get: function get() {
+    return _favorites.FAVORITES_CAPABILITY_ID;
+  }
+});
+Object.defineProperty(exports, "FAVORITES_FILTER", {
+  enumerable: true,
+  get: function get() {
+    return _favoritesView.FAVORITES_FILTER;
+  }
+});
+Object.defineProperty(exports, "FAVORITES_SORT", {
+  enumerable: true,
+  get: function get() {
+    return _favoritesView.FAVORITES_SORT;
+  }
+});
+Object.defineProperty(exports, "FavoriteToggle", {
+  enumerable: true,
+  get: function get() {
+    return _FavoriteToggle["default"];
+  }
+});
+Object.defineProperty(exports, "SAVED_FILTERS_CAPABILITY_ID", {
+  enumerable: true,
+  get: function get() {
+    return _savedFilters.SAVED_FILTERS_CAPABILITY_ID;
+  }
+});
+Object.defineProperty(exports, "UserPersonalizationProvider", {
+  enumerable: true,
+  get: function get() {
+    return _PersonalizationProvider["default"];
+  }
+});
+Object.defineProperty(exports, "createLocalStorageAdapter", {
+  enumerable: true,
+  get: function get() {
+    return _createLocalStorageAdapter["default"];
+  }
+});
+Object.defineProperty(exports, "createMemoryAdapter", {
+  enumerable: true,
+  get: function get() {
+    return _createMemoryAdapter["default"];
+  }
+});
+Object.defineProperty(exports, "filterRowsByFavorites", {
+  enumerable: true,
+  get: function get() {
+    return _favoritesView.filterRowsByFavorites;
+  }
+});
+Object.defineProperty(exports, "makeEnvelope", {
+  enumerable: true,
+  get: function get() {
+    return _schema.makeEnvelope;
+  }
+});
+Object.defineProperty(exports, "registerCapability", {
+  enumerable: true,
+  get: function get() {
+    return _schema.registerCapability;
+  }
+});
+Object.defineProperty(exports, "sortRowsByFavorites", {
+  enumerable: true,
+  get: function get() {
+    return _favoritesView.sortRowsByFavorites;
+  }
+});
+Object.defineProperty(exports, "useFavorites", {
+  enumerable: true,
+  get: function get() {
+    return _favorites.useFavorites;
+  }
+});
+Object.defineProperty(exports, "useFavoritesView", {
+  enumerable: true,
+  get: function get() {
+    return _favoritesView.useFavoritesView;
+  }
+});
+Object.defineProperty(exports, "useIsFavorite", {
+  enumerable: true,
+  get: function get() {
+    return _favorites.useIsFavorite;
+  }
+});
+Object.defineProperty(exports, "useSavedFilters", {
+  enumerable: true,
+  get: function get() {
+    return _savedFilters.useSavedFilters;
+  }
+});
+var _PersonalizationProvider = _interopRequireDefault(require("./PersonalizationProvider"));
+var _createLocalStorageAdapter = _interopRequireDefault(require("./adapters/createLocalStorageAdapter"));
+var _createMemoryAdapter = _interopRequireDefault(require("./adapters/createMemoryAdapter"));
+var _schema = require("./schema");
+var _favorites = require("./capabilities/favorites");
+var _favoritesView = require("./capabilities/favoritesView");
+var _FavoriteToggle = _interopRequireDefault(require("../components/FavoriteToggle"));
+var _savedFilters = require("./capabilities/savedFilters");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+//# sourceMappingURL=index.js.map

package/dist/v2/personalization/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_PersonalizationProvider","_interopRequireDefault","require","_createLocalStorageAdapter","_createMemoryAdapter","_schema","_favorites","_favoritesView","_FavoriteToggle","_savedFilters","obj","__esModule"],"sources":["../../../src/lib/v2/personalization/index.ts"],"sourcesContent":["/**\r\n * @portnet/ui · v2 · User Personalization Foundation\r\n * Public surface.\r\n *\r\n * Import via the dedicated subpath:\r\n *   import {\r\n *     UserPersonalizationProvider,\r\n *     useFavorites,\r\n *     useFavoritesView,\r\n *     useSavedFilters,\r\n *     FavoriteToggle,\r\n *   } from \"@portnet/ui/v2/personalization\";\r\n *\r\n * Surface is intentionally minimal (architecture doc §2.8 — minimum API\r\n * surface). The store handle and the internal selector primitive are NOT\r\n * exported; hosts interact through the provider, the capability hooks,\r\n * and the capability components.\r\n *\r\n * The grid-bound composites — SaveFilterDialog / SavedFiltersMenu (saved\r\n * filters) and makeFavoriteColumn / FavoritesFilter (favorites) — are\r\n * exposed via @portnet/ui/v2 (patterns/), not re-exported here, so the\r\n * personalization barrel never imports from patterns/.\r\n */\r\n\r\n/* Provider — the single configuration point. */\r\nexport { default as UserPersonalizationProvider } from \"./PersonalizationProvider\";\r\n\r\n/* Built-in storage adapters (a remote adapter will join them, swap-in). */\r\nexport { default as createLocalStorageAdapter } from \"./adapters/createLocalStorageAdapter\";\r\nexport { default as createMemoryAdapter } from \"./adapters/createMemoryAdapter\";\r\n\r\n/* Capability registration seam — for custom/host-defined capabilities. */\r\nexport { registerCapability, makeEnvelope } from \"./schema\";\r\n\r\n/* Canonical domain types — the TS contract that replaced the runtime\r\n * PropTypes shapes (Scope / Adapter / FavoriteRef / SavedFilter). Type-only:\r\n * erased from the runtime bundle. */\r\nexport type { Scope, Adapter, FavoriteRef, SavedFilter } from \"./types\";\r\n\r\n/* Favorites capability (Batch 3) + view logic (Batch 5). */\r\nexport { useFavorites, useIsFavorite, FAVORITES_CAPABILITY_ID } from \"./capabilities/favorites\";\r\nexport {\r\n  useFavoritesView,\r\n  filterRowsByFavorites,\r\n  sortRowsByFavorites,\r\n  FAVORITES_FILTER,\r\n  FAVORITES_SORT,\r\n} from \"./capabilities/favoritesView\";\r\nexport { default as FavoriteToggle } from \"../components/FavoriteToggle\";\r\n\r\n/* Saved filters capability (Batch 4). Composites in v2 patterns/. */\r\nexport { useSavedFilters, SAVED_FILTERS_CAPABILITY_ID } from \"./capabilities/savedFilters\";\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAAA,wBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAGA,IAAAC,0BAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,oBAAA,GAAAH,sBAAA,CAAAC,OAAA;AAGA,IAAAG,OAAA,GAAAH,OAAA;AAQA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,cAAA,GAAAL,OAAA;AAOA,IAAAM,eAAA,GAAAP,sBAAA,CAAAC,OAAA;AAGA,IAAAO,aAAA,GAAAP,OAAA;AAA2F,SAAAD,uBAAAS,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,gBAAAA,GAAA","ignoreList":[]}

package/dist/v2/personalization/personalizationContext.d.ts

@@ -0,0 +1,78 @@
+/**
+ * personalizationContext — Portnet UI v2 · personalization
+ *
+ * Two contexts, by design (architecture doc §2.5):
+ *   - PersonalizationConfigContext : STABLE config { scope, labels }, set
+ *     once by the provider. Low churn.
+ *   - PersonalizationStoreContext  : the store handle. Mutable preference
+ *     state NEVER travels through context — it is read via
+ *     useSyncExternalStore selectors. A component toggling a favorite
+ *     cannot re-render a component reading saved filters.
+ *
+ * `useStoreSelector` is the internal subscription primitive: a
+ * useSyncExternalStore wrapper that caches by (snapshot, selector) and
+ * supports an optional equality function so derived/object selections stay
+ * referentially stable. It is NOT exported from the public surface — the
+ * capability slices (Batch 3/4) consume it; hosts use the capability hooks.
+ */
+import * as React from "react";
+import type { PersonalizationSnapshot, PersonalizationStore } from "./createPersonalizationStore";
+import type { Scope } from "./types";
+/**
+ * Merged label bag (provider defaults + host overrides). The concrete
+ * default values live in DEFAULT_PERSONALIZATION_LABELS in the provider;
+ * this is the canonical type both the provider and the capability slices
+ * import.
+ */
+export interface PersonalizationLabels {
+    addFavorite: string;
+    removeFavorite: string;
+    favoritesOnly: string;
+    showAll: string;
+    favoriteColumnHeader: string;
+    savedFilters: string;
+    saveCurrentFilter: string;
+    filterNameLabel: string;
+    filterNamePlaceholder: string;
+    saveFilter: string;
+    updateFilter: string;
+    deleteFilter: string;
+    deleteFilterConfirm: string;
+    setAsDefault: string;
+    defaultBadge: string;
+    manageFilters: string;
+    noSavedFilters: string;
+    cancel: string;
+}
+/** Stable configuration carried by PersonalizationConfigContext. */
+export interface PersonalizationConfig {
+    scope: Scope;
+    labels: PersonalizationLabels;
+}
+export declare const PersonalizationConfigContext: React.Context<PersonalizationConfig | null>;
+export declare const PersonalizationStoreContext: React.Context<PersonalizationStore | null>;
+export declare function usePersonalizationConfig(): PersonalizationConfig;
+/** The store handle. */
+export declare function usePersonalizationStore(): PersonalizationStore;
+/** Convenience: the current scope. */
+export declare function useScope(): Scope;
+/** Convenience: merged labels (provider defaults + host overrides). */
+export declare function usePersonalizationLabels(): PersonalizationLabels;
+/**
+ * Subscribe to the store with a selector. Returns a referentially stable
+ * value when the selected slice is unchanged — required by
+ * useSyncExternalStore and the basis of the no-cross-capability-re-render
+ * guarantee.
+ *
+ * The cache is keyed on (snapshot identity, selector identity, isEqual
+ * identity). When the snapshot is unchanged for the same selector, the
+ * memoised selection is returned without re-running the selector. When the
+ * snapshot changes, the selector re-runs; if `isEqual` is supplied and the
+ * new value is equal to the previous one, the previous reference is kept.
+ *
+ * Selectors should be stable (e.g. useCallback) OR rely on the store's
+ * structural sharing returning stable slice references — both keep this
+ * loop-free.
+ */
+export declare function useStoreSelector<T>(selector: (snapshot: PersonalizationSnapshot) => T, isEqual?: (a: T, b: T) => boolean): T;
+//# sourceMappingURL=personalizationContext.d.ts.map

package/dist/v2/personalization/personalizationContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"personalizationContext.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/personalization/personalizationContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EACV,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IAEpC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,oBAAoB,EAAE,MAAM,CAAC;IAE7B,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,oEAAoE;AACpE,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,qBAAqB,CAAC;CAC/B;AAED,eAAO,MAAM,4BAA4B,6CACgB,CAAC;AAC1D,eAAO,MAAM,2BAA2B,4CACgB,CAAC;AAEzD,wBAAgB,wBAAwB,IAAI,qBAAqB,CAQhE;AAED,wBAAwB;AACxB,wBAAgB,uBAAuB,IAAI,oBAAoB,CAQ9D;AAED,sCAAsC;AACtC,wBAAgB,QAAQ,IAAI,KAAK,CAEhC;AAED,uEAAuE;AACvE,wBAAgB,wBAAwB,IAAI,qBAAqB,CAEhE;AAUD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,QAAQ,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,CAAC,EAClD,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAChC,CAAC,CAkDH"}

package/dist/v2/personalization/personalizationContext.js

@@ -0,0 +1,121 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PersonalizationStoreContext = exports.PersonalizationConfigContext = void 0;
+exports.usePersonalizationConfig = usePersonalizationConfig;
+exports.usePersonalizationLabels = usePersonalizationLabels;
+exports.usePersonalizationStore = usePersonalizationStore;
+exports.useScope = useScope;
+exports.useStoreSelector = useStoreSelector;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * personalizationContext — Portnet UI v2 · personalization
+ *
+ * Two contexts, by design (architecture doc §2.5):
+ *   - PersonalizationConfigContext : STABLE config { scope, labels }, set
+ *     once by the provider. Low churn.
+ *   - PersonalizationStoreContext  : the store handle. Mutable preference
+ *     state NEVER travels through context — it is read via
+ *     useSyncExternalStore selectors. A component toggling a favorite
+ *     cannot re-render a component reading saved filters.
+ *
+ * `useStoreSelector` is the internal subscription primitive: a
+ * useSyncExternalStore wrapper that caches by (snapshot, selector) and
+ * supports an optional equality function so derived/object selections stay
+ * referentially stable. It is NOT exported from the public surface — the
+ * capability slices (Batch 3/4) consume it; hosts use the capability hooks.
+ */
+
+/**
+ * Merged label bag (provider defaults + host overrides). The concrete
+ * default values live in DEFAULT_PERSONALIZATION_LABELS in the provider;
+ * this is the canonical type both the provider and the capability slices
+ * import.
+ */
+
+/** Stable configuration carried by PersonalizationConfigContext. */
+
+var PersonalizationConfigContext = exports.PersonalizationConfigContext = /*#__PURE__*/React.createContext(null);
+var PersonalizationStoreContext = exports.PersonalizationStoreContext = /*#__PURE__*/React.createContext(null);
+function usePersonalizationConfig() {
+  var ctx = React.useContext(PersonalizationConfigContext);
+  if (!ctx) {
+    throw new Error("[@portnet/ui v2] usePersonalizationConfig() must be used inside <UserPersonalizationProvider>.");
+  }
+  return ctx;
+}
+
+/** The store handle. */
+function usePersonalizationStore() {
+  var store = React.useContext(PersonalizationStoreContext);
+  if (!store) {
+    throw new Error("[@portnet/ui v2] personalization hooks must be used inside <UserPersonalizationProvider>.");
+  }
+  return store;
+}
+
+/** Convenience: the current scope. */
+function useScope() {
+  return usePersonalizationConfig().scope;
+}
+
+/** Convenience: merged labels (provider defaults + host overrides). */
+function usePersonalizationLabels() {
+  return usePersonalizationConfig().labels;
+}
+/**
+ * Subscribe to the store with a selector. Returns a referentially stable
+ * value when the selected slice is unchanged — required by
+ * useSyncExternalStore and the basis of the no-cross-capability-re-render
+ * guarantee.
+ *
+ * The cache is keyed on (snapshot identity, selector identity, isEqual
+ * identity). When the snapshot is unchanged for the same selector, the
+ * memoised selection is returned without re-running the selector. When the
+ * snapshot changes, the selector re-runs; if `isEqual` is supplied and the
+ * new value is equal to the previous one, the previous reference is kept.
+ *
+ * Selectors should be stable (e.g. useCallback) OR rely on the store's
+ * structural sharing returning stable slice references — both keep this
+ * loop-free.
+ */
+function useStoreSelector(selector, isEqual) {
+  var store = usePersonalizationStore();
+  var cacheRef = React.useRef(null);
+  function getSelection() {
+    var snapshot = store.getSnapshot();
+    var cache = cacheRef.current;
+    if (cache && Object.is(cache.snapshot, snapshot) && cache.selector === selector && cache.isEqual === isEqual) {
+      return cache.selection;
+    }
+    var nextSelection = selector(snapshot);
+    if (cache && cache.hasValue && typeof isEqual === "function" && isEqual(cache.selection, nextSelection)) {
+      cacheRef.current = {
+        snapshot: snapshot,
+        selector: selector,
+        isEqual: isEqual,
+        selection: cache.selection,
+        hasValue: true
+      };
+      return cache.selection;
+    }
+    cacheRef.current = {
+      snapshot: snapshot,
+      selector: selector,
+      isEqual: isEqual,
+      selection: nextSelection,
+      hasValue: true
+    };
+    return nextSelection;
+  }
+  function getServerSelection() {
+    return selector(store.getServerSnapshot());
+  }
+  return React.useSyncExternalStore(store.subscribe, getSelection, getServerSelection);
+}
+//# sourceMappingURL=personalizationContext.js.map

package/dist/v2/personalization/personalizationContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"personalizationContext.js","names":["React","_interopRequireWildcard","require","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","_typeof","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","PersonalizationConfigContext","exports","createContext","PersonalizationStoreContext","usePersonalizationConfig","ctx","useContext","Error","usePersonalizationStore","store","useScope","scope","usePersonalizationLabels","labels","useStoreSelector","selector","isEqual","cacheRef","useRef","getSelection","snapshot","getSnapshot","current","is","selection","nextSelection","hasValue","getServerSelection","getServerSnapshot","useSyncExternalStore","subscribe"],"sources":["../../../src/lib/v2/personalization/personalizationContext.ts"],"sourcesContent":["/**\r\n * personalizationContext — Portnet UI v2 · personalization\r\n *\r\n * Two contexts, by design (architecture doc §2.5):\r\n *   - PersonalizationConfigContext : STABLE config { scope, labels }, set\r\n *     once by the provider. Low churn.\r\n *   - PersonalizationStoreContext  : the store handle. Mutable preference\r\n *     state NEVER travels through context — it is read via\r\n *     useSyncExternalStore selectors. A component toggling a favorite\r\n *     cannot re-render a component reading saved filters.\r\n *\r\n * `useStoreSelector` is the internal subscription primitive: a\r\n * useSyncExternalStore wrapper that caches by (snapshot, selector) and\r\n * supports an optional equality function so derived/object selections stay\r\n * referentially stable. It is NOT exported from the public surface — the\r\n * capability slices (Batch 3/4) consume it; hosts use the capability hooks.\r\n */\r\n\r\nimport * as React from \"react\";\r\n\r\nimport type {\r\n  PersonalizationSnapshot,\r\n  PersonalizationStore,\r\n} from \"./createPersonalizationStore\";\r\nimport type { Scope } from \"./types\";\r\n\r\n/**\r\n * Merged label bag (provider defaults + host overrides). The concrete\r\n * default values live in DEFAULT_PERSONALIZATION_LABELS in the provider;\r\n * this is the canonical type both the provider and the capability slices\r\n * import.\r\n */\r\nexport interface PersonalizationLabels {\r\n  // Follow / \"suivis\" (Batch 3)\r\n  addFavorite: string;\r\n  removeFavorite: string;\r\n  favoritesOnly: string;\r\n  showAll: string;\r\n  favoriteColumnHeader: string;\r\n  // Saved filters (Batch 4)\r\n  savedFilters: string;\r\n  saveCurrentFilter: string;\r\n  filterNameLabel: string;\r\n  filterNamePlaceholder: string;\r\n  saveFilter: string;\r\n  updateFilter: string;\r\n  deleteFilter: string;\r\n  deleteFilterConfirm: string;\r\n  setAsDefault: string;\r\n  defaultBadge: string;\r\n  manageFilters: string;\r\n  noSavedFilters: string;\r\n  cancel: string;\r\n}\r\n\r\n/** Stable configuration carried by PersonalizationConfigContext. */\r\nexport interface PersonalizationConfig {\r\n  scope: Scope;\r\n  labels: PersonalizationLabels;\r\n}\r\n\r\nexport const PersonalizationConfigContext =\r\n  React.createContext<PersonalizationConfig | null>(null);\r\nexport const PersonalizationStoreContext =\r\n  React.createContext<PersonalizationStore | null>(null);\r\n\r\nexport function usePersonalizationConfig(): PersonalizationConfig {\r\n  const ctx = React.useContext(PersonalizationConfigContext);\r\n  if (!ctx) {\r\n    throw new Error(\r\n      \"[@portnet/ui v2] usePersonalizationConfig() must be used inside <UserPersonalizationProvider>.\"\r\n    );\r\n  }\r\n  return ctx;\r\n}\r\n\r\n/** The store handle. */\r\nexport function usePersonalizationStore(): PersonalizationStore {\r\n  const store = React.useContext(PersonalizationStoreContext);\r\n  if (!store) {\r\n    throw new Error(\r\n      \"[@portnet/ui v2] personalization hooks must be used inside <UserPersonalizationProvider>.\"\r\n    );\r\n  }\r\n  return store;\r\n}\r\n\r\n/** Convenience: the current scope. */\r\nexport function useScope(): Scope {\r\n  return usePersonalizationConfig().scope;\r\n}\r\n\r\n/** Convenience: merged labels (provider defaults + host overrides). */\r\nexport function usePersonalizationLabels(): PersonalizationLabels {\r\n  return usePersonalizationConfig().labels;\r\n}\r\n\r\ninterface SelectorCache<T> {\r\n  snapshot: PersonalizationSnapshot;\r\n  selector: (snapshot: PersonalizationSnapshot) => T;\r\n  isEqual: ((a: T, b: T) => boolean) | undefined;\r\n  selection: T;\r\n  hasValue: boolean;\r\n}\r\n\r\n/**\r\n * Subscribe to the store with a selector. Returns a referentially stable\r\n * value when the selected slice is unchanged — required by\r\n * useSyncExternalStore and the basis of the no-cross-capability-re-render\r\n * guarantee.\r\n *\r\n * The cache is keyed on (snapshot identity, selector identity, isEqual\r\n * identity). When the snapshot is unchanged for the same selector, the\r\n * memoised selection is returned without re-running the selector. When the\r\n * snapshot changes, the selector re-runs; if `isEqual` is supplied and the\r\n * new value is equal to the previous one, the previous reference is kept.\r\n *\r\n * Selectors should be stable (e.g. useCallback) OR rely on the store's\r\n * structural sharing returning stable slice references — both keep this\r\n * loop-free.\r\n */\r\nexport function useStoreSelector<T>(\r\n  selector: (snapshot: PersonalizationSnapshot) => T,\r\n  isEqual?: (a: T, b: T) => boolean\r\n): T {\r\n  const store = usePersonalizationStore();\r\n  const cacheRef = React.useRef<SelectorCache<T> | null>(null);\r\n\r\n  function getSelection(): T {\r\n    const snapshot = store.getSnapshot();\r\n    const cache = cacheRef.current;\r\n    if (\r\n      cache &&\r\n      Object.is(cache.snapshot, snapshot) &&\r\n      cache.selector === selector &&\r\n      cache.isEqual === isEqual\r\n    ) {\r\n      return cache.selection;\r\n    }\r\n    const nextSelection = selector(snapshot);\r\n    if (\r\n      cache &&\r\n      cache.hasValue &&\r\n      typeof isEqual === \"function\" &&\r\n      isEqual(cache.selection, nextSelection)\r\n    ) {\r\n      cacheRef.current = {\r\n        snapshot: snapshot,\r\n        selector: selector,\r\n        isEqual: isEqual,\r\n        selection: cache.selection,\r\n        hasValue: true,\r\n      };\r\n      return cache.selection;\r\n    }\r\n    cacheRef.current = {\r\n      snapshot: snapshot,\r\n      selector: selector,\r\n      isEqual: isEqual,\r\n      selection: nextSelection,\r\n      hasValue: true,\r\n    };\r\n    return nextSelection;\r\n  }\r\n\r\n  function getServerSelection(): T {\r\n    return selector(store.getServerSnapshot());\r\n  }\r\n\r\n  return React.useSyncExternalStore(\r\n    store.subscribe,\r\n    getSelection,\r\n    getServerSelection\r\n  );\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/v2/personalization/schema.d.ts

@@ -0,0 +1,60 @@
+/**
+ * schema — Portnet UI v2 · User Personalization Foundation
+ *
+ * Capability registry + persistence envelope. The foundation is deliberately
+ * capability-AGNOSTIC: the store and provider know nothing about "favorites"
+ * or "savedFilters". Each capability *slice* registers itself here at import
+ * time:
+ *
+ *   import { registerCapability } from "../schema";
+ *   registerCapability({
+ *     id: "favorites",
+ *     schemaVersion: 1,
+ *     defaultState: Object.freeze({}),
+ *     migrate: (fromVersion, payload) => payload,
+ *   });
+ *
+ * Adding a new capability is therefore purely additive. The adapter persists
+ * the OPAQUE envelope; the `payload` shape is owned by the slice.
+ */
+import type { Envelope } from "./types";
+/** A capability's migrate function: upgrade an old payload to the current version. */
+export type CapabilityMigrate = (fromVersion: number, payload: unknown) => unknown;
+/** Registration input for a capability slice. */
+export interface CapabilityDescriptorInput {
+    /** Unique capability id (e.g. "favorites"). */
+    id: string;
+    schemaVersion?: number;
+    /** Seed when nothing is persisted (should be a STABLE/frozen ref). */
+    defaultState?: unknown;
+    migrate?: CapabilityMigrate;
+}
+/** Frozen, normalised capability descriptor stored in the registry. */
+export interface CapabilityDescriptor {
+    id: string;
+    schemaVersion: number;
+    defaultState: unknown;
+    migrate: CapabilityMigrate | null;
+}
+/**
+ * Register a capability descriptor. Idempotent: the first registration for an
+ * id wins; a second registration with a *different* schemaVersion is reported
+ * in development (usually two library copies or a mismatched host version).
+ */
+export declare function registerCapability(descriptor: CapabilityDescriptorInput): CapabilityDescriptor | null;
+/** @returns the descriptor registered for `id`, or null. */
+export declare function getCapability(id: string): CapabilityDescriptor | null;
+/** @returns every registered descriptor (snapshot array). */
+export declare function getRegisteredCapabilities(): CapabilityDescriptor[];
+/**
+ * Build the versioned persistence envelope. The adapter treats `payload` as
+ * opaque; `schemaVersion` lets a slice's migrate() upgrade old payloads on load.
+ */
+export declare function makeEnvelope(schemaVersion: number, payload: unknown): Envelope;
+/**
+ * Key-scheme version (the layout of the *storage key*, distinct from a
+ * capability's payload `schemaVersion`). Bumped only on a global re-partition.
+ * Mirrored by adapters/_storageKey.ts.
+ */
+export declare const KEY_SCHEME_VERSION = "v1";
+//# sourceMappingURL=schema.d.ts.map

package/dist/v2/personalization/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/personalization/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAOxC,sFAAsF;AACtF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,OAAO,KACb,OAAO,CAAC;AAEb,iDAAiD;AACjD,MAAM,WAAW,yBAAyB;IACxC,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sEAAsE;IACtE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B;AAED,uEAAuE;AACvE,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAAC;CACnC;AAKD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,yBAAyB,GACpC,oBAAoB,GAAG,IAAI,CAuC7B;AAED,4DAA4D;AAC5D,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAErE;AAED,6DAA6D;AAC7D,wBAAgB,yBAAyB,IAAI,oBAAoB,EAAE,CAElE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,CAM9E;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAC"}

package/dist/v2/personalization/schema.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KEY_SCHEME_VERSION = void 0;
+exports.getCapability = getCapability;
+exports.getRegisteredCapabilities = getRegisteredCapabilities;
+exports.makeEnvelope = makeEnvelope;
+exports.registerCapability = registerCapability;
+/**
+ * schema — Portnet UI v2 · User Personalization Foundation
+ *
+ * Capability registry + persistence envelope. The foundation is deliberately
+ * capability-AGNOSTIC: the store and provider know nothing about "favorites"
+ * or "savedFilters". Each capability *slice* registers itself here at import
+ * time:
+ *
+ *   import { registerCapability } from "../schema";
+ *   registerCapability({
+ *     id: "favorites",
+ *     schemaVersion: 1,
+ *     defaultState: Object.freeze({}),
+ *     migrate: (fromVersion, payload) => payload,
+ *   });
+ *
+ * Adding a new capability is therefore purely additive. The adapter persists
+ * the OPAQUE envelope; the `payload` shape is owned by the slice.
+ */
+
+var isDev = typeof process !== "undefined" && !!process.env && process.env["NODE_ENV"] !== "production";
+
+/** A capability's migrate function: upgrade an old payload to the current version. */
+
+/** Registration input for a capability slice. */
+
+/** Frozen, normalised capability descriptor stored in the registry. */
+
+/** id -> frozen descriptor. Module-level (same lifecycle model as useDensity's store). */
+var registry = new Map();
+
+/**
+ * Register a capability descriptor. Idempotent: the first registration for an
+ * id wins; a second registration with a *different* schemaVersion is reported
+ * in development (usually two library copies or a mismatched host version).
+ */
+function registerCapability(descriptor) {
+  if (!descriptor || typeof descriptor.id !== "string" || !descriptor.id) {
+    if (isDev) {
+      // eslint-disable-next-line no-console
+      console.warn("[@portnet/ui v2] registerCapability: a non-empty string `id` is required.");
+    }
+    return null;
+  }
+  var existing = registry.get(descriptor.id);
+  if (existing) {
+    var _descriptor$schemaVer;
+    if (isDev && existing.schemaVersion !== ((_descriptor$schemaVer = descriptor.schemaVersion) !== null && _descriptor$schemaVer !== void 0 ? _descriptor$schemaVer : 1)) {
+      // eslint-disable-next-line no-console
+      console.warn("[@portnet/ui v2] registerCapability: \"".concat(descriptor.id, "\" re-registered with a different ") + "schemaVersion (".concat(existing.schemaVersion, " \u2192 ").concat(descriptor.schemaVersion, "). Keeping the first ") + "registration. This usually means two @portnet/ui copies are loaded.");
+    }
+    return existing;
+  }
+  var frozen = Object.freeze({
+    id: descriptor.id,
+    schemaVersion: typeof descriptor.schemaVersion === "number" ? descriptor.schemaVersion : 1,
+    defaultState: descriptor.defaultState !== undefined ? descriptor.defaultState : Object.freeze({}),
+    migrate: typeof descriptor.migrate === "function" ? descriptor.migrate : null
+  });
+  registry.set(frozen.id, frozen);
+  return frozen;
+}
+
+/** @returns the descriptor registered for `id`, or null. */
+function getCapability(id) {
+  return registry.get(id) || null;
+}
+
+/** @returns every registered descriptor (snapshot array). */
+function getRegisteredCapabilities() {
+  return Array.from(registry.values());
+}
+
+/**
+ * Build the versioned persistence envelope. The adapter treats `payload` as
+ * opaque; `schemaVersion` lets a slice's migrate() upgrade old payloads on load.
+ */
+function makeEnvelope(schemaVersion, payload) {
+  return {
+    schemaVersion: typeof schemaVersion === "number" ? schemaVersion : 1,
+    updatedAt: new Date().toISOString(),
+    payload: payload
+  };
+}
+
+/**
+ * Key-scheme version (the layout of the *storage key*, distinct from a
+ * capability's payload `schemaVersion`). Bumped only on a global re-partition.
+ * Mirrored by adapters/_storageKey.ts.
+ */
+var KEY_SCHEME_VERSION = exports.KEY_SCHEME_VERSION = "v1";
+//# sourceMappingURL=schema.js.map

package/dist/v2/personalization/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","names":["isDev","process","env","registry","Map","registerCapability","descriptor","id","console","warn","existing","get","_descriptor$schemaVer","schemaVersion","concat","frozen","Object","freeze","defaultState","undefined","migrate","set","getCapability","getRegisteredCapabilities","Array","from","values","makeEnvelope","payload","updatedAt","Date","toISOString","KEY_SCHEME_VERSION","exports"],"sources":["../../../src/lib/v2/personalization/schema.ts"],"sourcesContent":["/**\r\n * schema — Portnet UI v2 · User Personalization Foundation\r\n *\r\n * Capability registry + persistence envelope. The foundation is deliberately\r\n * capability-AGNOSTIC: the store and provider know nothing about \"favorites\"\r\n * or \"savedFilters\". Each capability *slice* registers itself here at import\r\n * time:\r\n *\r\n *   import { registerCapability } from \"../schema\";\r\n *   registerCapability({\r\n *     id: \"favorites\",\r\n *     schemaVersion: 1,\r\n *     defaultState: Object.freeze({}),\r\n *     migrate: (fromVersion, payload) => payload,\r\n *   });\r\n *\r\n * Adding a new capability is therefore purely additive. The adapter persists\r\n * the OPAQUE envelope; the `payload` shape is owned by the slice.\r\n */\r\n\r\nimport type { Envelope } from \"./types\";\r\n\r\nconst isDev =\r\n  typeof process !== \"undefined\" &&\r\n  !!process.env &&\r\n  process.env[\"NODE_ENV\"] !== \"production\";\r\n\r\n/** A capability's migrate function: upgrade an old payload to the current version. */\r\nexport type CapabilityMigrate = (\r\n  fromVersion: number,\r\n  payload: unknown\r\n) => unknown;\r\n\r\n/** Registration input for a capability slice. */\r\nexport interface CapabilityDescriptorInput {\r\n  /** Unique capability id (e.g. \"favorites\"). */\r\n  id: string;\r\n  schemaVersion?: number;\r\n  /** Seed when nothing is persisted (should be a STABLE/frozen ref). */\r\n  defaultState?: unknown;\r\n  migrate?: CapabilityMigrate;\r\n}\r\n\r\n/** Frozen, normalised capability descriptor stored in the registry. */\r\nexport interface CapabilityDescriptor {\r\n  id: string;\r\n  schemaVersion: number;\r\n  defaultState: unknown;\r\n  migrate: CapabilityMigrate | null;\r\n}\r\n\r\n/** id -> frozen descriptor. Module-level (same lifecycle model as useDensity's store). */\r\nconst registry = new Map<string, CapabilityDescriptor>();\r\n\r\n/**\r\n * Register a capability descriptor. Idempotent: the first registration for an\r\n * id wins; a second registration with a *different* schemaVersion is reported\r\n * in development (usually two library copies or a mismatched host version).\r\n */\r\nexport function registerCapability(\r\n  descriptor: CapabilityDescriptorInput\r\n): CapabilityDescriptor | null {\r\n  if (!descriptor || typeof descriptor.id !== \"string\" || !descriptor.id) {\r\n    if (isDev) {\r\n      // eslint-disable-next-line no-console\r\n      console.warn(\r\n        \"[@portnet/ui v2] registerCapability: a non-empty string `id` is required.\"\r\n      );\r\n    }\r\n    return null;\r\n  }\r\n\r\n  const existing = registry.get(descriptor.id);\r\n  if (existing) {\r\n    if (isDev && existing.schemaVersion !== (descriptor.schemaVersion ?? 1)) {\r\n      // eslint-disable-next-line no-console\r\n      console.warn(\r\n        `[@portnet/ui v2] registerCapability: \"${descriptor.id}\" re-registered with a different ` +\r\n          `schemaVersion (${existing.schemaVersion} → ${descriptor.schemaVersion}). Keeping the first ` +\r\n          `registration. This usually means two @portnet/ui copies are loaded.`\r\n      );\r\n    }\r\n    return existing;\r\n  }\r\n\r\n  const frozen: CapabilityDescriptor = Object.freeze({\r\n    id: descriptor.id,\r\n    schemaVersion:\r\n      typeof descriptor.schemaVersion === \"number\"\r\n        ? descriptor.schemaVersion\r\n        : 1,\r\n    defaultState:\r\n      descriptor.defaultState !== undefined\r\n        ? descriptor.defaultState\r\n        : Object.freeze({}),\r\n    migrate:\r\n      typeof descriptor.migrate === \"function\" ? descriptor.migrate : null,\r\n  });\r\n  registry.set(frozen.id, frozen);\r\n  return frozen;\r\n}\r\n\r\n/** @returns the descriptor registered for `id`, or null. */\r\nexport function getCapability(id: string): CapabilityDescriptor | null {\r\n  return registry.get(id) || null;\r\n}\r\n\r\n/** @returns every registered descriptor (snapshot array). */\r\nexport function getRegisteredCapabilities(): CapabilityDescriptor[] {\r\n  return Array.from(registry.values());\r\n}\r\n\r\n/**\r\n * Build the versioned persistence envelope. The adapter treats `payload` as\r\n * opaque; `schemaVersion` lets a slice's migrate() upgrade old payloads on load.\r\n */\r\nexport function makeEnvelope(schemaVersion: number, payload: unknown): Envelope {\r\n  return {\r\n    schemaVersion: typeof schemaVersion === \"number\" ? schemaVersion : 1,\r\n    updatedAt: new Date().toISOString(),\r\n    payload,\r\n  };\r\n}\r\n\r\n/**\r\n * Key-scheme version (the layout of the *storage key*, distinct from a\r\n * capability's payload `schemaVersion`). Bumped only on a global re-partition.\r\n * Mirrored by adapters/_storageKey.ts.\r\n */\r\nexport const KEY_SCHEME_VERSION = \"v1\";\r\n"],"mappings":";;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,IAAMA,KAAK,GACT,OAAOC,OAAO,KAAK,WAAW,IAC9B,CAAC,CAACA,OAAO,CAACC,GAAG,IACbD,OAAO,CAACC,GAAG,CAAC,UAAU,CAAC,KAAK,YAAY;;AAE1C;;AAMA;;AAUA;;AAQA;AACA,IAAMC,QAAQ,GAAG,IAAIC,GAAG,CAA+B,CAAC;;AAExD;AACA;AACA;AACA;AACA;AACO,SAASC,kBAAkBA,CAChCC,UAAqC,EACR;EAC7B,IAAI,CAACA,UAAU,IAAI,OAAOA,UAAU,CAACC,EAAE,KAAK,QAAQ,IAAI,CAACD,UAAU,CAACC,EAAE,EAAE;IACtE,IAAIP,KAAK,EAAE;MACT;MACAQ,OAAO,CAACC,IAAI,CACV,2EACF,CAAC;IACH;IACA,OAAO,IAAI;EACb;EAEA,IAAMC,QAAQ,GAAGP,QAAQ,CAACQ,GAAG,CAACL,UAAU,CAACC,EAAE,CAAC;EAC5C,IAAIG,QAAQ,EAAE;IAAA,IAAAE,qBAAA;IACZ,IAAIZ,KAAK,IAAIU,QAAQ,CAACG,aAAa,OAAAD,qBAAA,GAAMN,UAAU,CAACO,aAAa,cAAAD,qBAAA,cAAAA,qBAAA,GAAI,CAAC,CAAC,EAAE;MACvE;MACAJ,OAAO,CAACC,IAAI,CACV,0CAAAK,MAAA,CAAyCR,UAAU,CAACC,EAAE,4DAAAO,MAAA,CAClCJ,QAAQ,CAACG,aAAa,cAAAC,MAAA,CAAMR,UAAU,CAACO,aAAa,0BAAuB,wEAEjG,CAAC;IACH;IACA,OAAOH,QAAQ;EACjB;EAEA,IAAMK,MAA4B,GAAGC,MAAM,CAACC,MAAM,CAAC;IACjDV,EAAE,EAAED,UAAU,CAACC,EAAE;IACjBM,aAAa,EACX,OAAOP,UAAU,CAACO,aAAa,KAAK,QAAQ,GACxCP,UAAU,CAACO,aAAa,GACxB,CAAC;IACPK,YAAY,EACVZ,UAAU,CAACY,YAAY,KAAKC,SAAS,GACjCb,UAAU,CAACY,YAAY,GACvBF,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,CAAC;IACvBG,OAAO,EACL,OAAOd,UAAU,CAACc,OAAO,KAAK,UAAU,GAAGd,UAAU,CAACc,OAAO,GAAG;EACpE,CAAC,CAAC;EACFjB,QAAQ,CAACkB,GAAG,CAACN,MAAM,CAACR,EAAE,EAAEQ,MAAM,CAAC;EAC/B,OAAOA,MAAM;AACf;;AAEA;AACO,SAASO,aAAaA,CAACf,EAAU,EAA+B;EACrE,OAAOJ,QAAQ,CAACQ,GAAG,CAACJ,EAAE,CAAC,IAAI,IAAI;AACjC;;AAEA;AACO,SAASgB,yBAAyBA,CAAA,EAA2B;EAClE,OAAOC,KAAK,CAACC,IAAI,CAACtB,QAAQ,CAACuB,MAAM,CAAC,CAAC,CAAC;AACtC;;AAEA;AACA;AACA;AACA;AACO,SAASC,YAAYA,CAACd,aAAqB,EAAEe,OAAgB,EAAY;EAC9E,OAAO;IACLf,aAAa,EAAE,OAAOA,aAAa,KAAK,QAAQ,GAAGA,aAAa,GAAG,CAAC;IACpEgB,SAAS,EAAE,IAAIC,IAAI,CAAC,CAAC,CAACC,WAAW,CAAC,CAAC;IACnCH,OAAO,EAAPA;EACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACO,IAAMI,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAAG,IAAI","ignoreList":[]}

package/dist/v2/personalization/types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * types — Portnet UI v2 · User Personalization Foundation
+ *
+ * Canonical TypeScript contracts for the personalization foundation. Replaces
+ * the former runtime propTypes.js "type surface": the provider, the
+ * store-backed hooks, and the capability components all type against these
+ * shared interfaces.
+ */
+import type { RowId } from "../types/common";
+/**
+ * Scope — partitions persisted preferences. `userId` is required; the rest
+ * are optional partitions (multi-tenant / per-app).
+ */
+export interface Scope {
+    userId: string;
+    tenantId?: string;
+    appId?: string;
+}
+/**
+ * Versioned persistence envelope. The adapter treats `payload` as opaque;
+ * `schemaVersion` lets a capability slice migrate old payloads on load.
+ */
+export interface Envelope<T = unknown> {
+    schemaVersion: number;
+    updatedAt: string;
+    payload: T;
+}
+/** Behaviour flags an adapter advertises to the store. */
+export interface AdapterCapabilities {
+    crossTab?: boolean;
+    remote?: boolean;
+    shared?: boolean;
+}
+/**
+ * Storage adapter contract. `load` + `save` are mandatory; the rest are
+ * optional capabilities the store feature-detects:
+ *   - loadSync   : synchronous hydrate (removes the initial empty flash for
+ *                  local adapters; absent on remote adapters)
+ *   - remove     : drop one capability blob
+ *   - subscribe  : external-change notifications (cross-tab / server push);
+ *                  returns an unsubscribe function
+ *   - capabilities : { crossTab, remote, shared } behaviour flags
+ *
+ * `load` / `loadSync` return a map of capabilityId -> envelope for the scope.
+ */
+export interface Adapter {
+    name?: string;
+    load: (scope: Scope) => Promise<Record<string, Envelope>>;
+    loadSync?: (scope: Scope) => Record<string, Envelope>;
+    save: (scope: Scope, capabilityId: string, envelope: Envelope) => Promise<void>;
+    remove?: (scope: Scope, capabilityId: string) => Promise<void>;
+    subscribe?: (scope: Scope, onChange: (capabilityId: string) => void) => () => void;
+    capabilities?: AdapterCapabilities;
+}
+/** Reconciliation strategy between optimistic local state and adapter truth. */
+export type HydrateStrategy = "local-wins" | "remote-wins" | "merge";
+/**
+ * Favorites — a single favorited entity reference. `id` is the business row
+ * id; `addedAt` enables future "recently favorited" ordering.
+ */
+export interface FavoriteRef {
+    id: RowId;
+    addedAt?: string;
+}
+/**
+ * Saved filter. `criteria` is opaque — the host's own filter payload,
+ * persisted and re-emitted verbatim so the framework stays reusable across
+ * every list regardless of its filter schema.
+ */
+export interface SavedFilter {
+    id: string;
+    name?: string;
+    resourceKey?: string;
+    criteria?: Record<string, unknown>;
+    ownerId?: string;
+    isDefault?: boolean;
+    shared?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/v2/personalization/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/personalization/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,CAAC,CAAC;CACZ;AAED,0DAA0D;AAC1D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACtD,IAAI,EAAE,CACJ,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,QAAQ,KACf,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,SAAS,CAAC,EAAE,CACV,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,KACrC,MAAM,IAAI,CAAC;IAChB,YAAY,CAAC,EAAE,mBAAmB,CAAC;CACpC;AAED,gFAAgF;AAChF,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,aAAa,GAAG,OAAO,CAAC;AAErE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/dist/v2/personalization/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/dist/v2/personalization/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/lib/v2/personalization/types.ts"],"sourcesContent":["/**\r\n * types — Portnet UI v2 · User Personalization Foundation\r\n *\r\n * Canonical TypeScript contracts for the personalization foundation. Replaces\r\n * the former runtime propTypes.js \"type surface\": the provider, the\r\n * store-backed hooks, and the capability components all type against these\r\n * shared interfaces.\r\n */\r\n\r\nimport type { RowId } from \"../types/common\";\r\n\r\n/**\r\n * Scope — partitions persisted preferences. `userId` is required; the rest\r\n * are optional partitions (multi-tenant / per-app).\r\n */\r\nexport interface Scope {\r\n  userId: string;\r\n  tenantId?: string;\r\n  appId?: string;\r\n}\r\n\r\n/**\r\n * Versioned persistence envelope. The adapter treats `payload` as opaque;\r\n * `schemaVersion` lets a capability slice migrate old payloads on load.\r\n */\r\nexport interface Envelope<T = unknown> {\r\n  schemaVersion: number;\r\n  updatedAt: string;\r\n  payload: T;\r\n}\r\n\r\n/** Behaviour flags an adapter advertises to the store. */\r\nexport interface AdapterCapabilities {\r\n  crossTab?: boolean;\r\n  remote?: boolean;\r\n  shared?: boolean;\r\n}\r\n\r\n/**\r\n * Storage adapter contract. `load` + `save` are mandatory; the rest are\r\n * optional capabilities the store feature-detects:\r\n *   - loadSync   : synchronous hydrate (removes the initial empty flash for\r\n *                  local adapters; absent on remote adapters)\r\n *   - remove     : drop one capability blob\r\n *   - subscribe  : external-change notifications (cross-tab / server push);\r\n *                  returns an unsubscribe function\r\n *   - capabilities : { crossTab, remote, shared } behaviour flags\r\n *\r\n * `load` / `loadSync` return a map of capabilityId -> envelope for the scope.\r\n */\r\nexport interface Adapter {\r\n  name?: string;\r\n  load: (scope: Scope) => Promise<Record<string, Envelope>>;\r\n  loadSync?: (scope: Scope) => Record<string, Envelope>;\r\n  save: (\r\n    scope: Scope,\r\n    capabilityId: string,\r\n    envelope: Envelope\r\n  ) => Promise<void>;\r\n  remove?: (scope: Scope, capabilityId: string) => Promise<void>;\r\n  subscribe?: (\r\n    scope: Scope,\r\n    onChange: (capabilityId: string) => void\r\n  ) => () => void;\r\n  capabilities?: AdapterCapabilities;\r\n}\r\n\r\n/** Reconciliation strategy between optimistic local state and adapter truth. */\r\nexport type HydrateStrategy = \"local-wins\" | \"remote-wins\" | \"merge\";\r\n\r\n/**\r\n * Favorites — a single favorited entity reference. `id` is the business row\r\n * id; `addedAt` enables future \"recently favorited\" ordering.\r\n */\r\nexport interface FavoriteRef {\r\n  id: RowId;\r\n  addedAt?: string;\r\n}\r\n\r\n/**\r\n * Saved filter. `criteria` is opaque — the host's own filter payload,\r\n * persisted and re-emitted verbatim so the framework stays reusable across\r\n * every list regardless of its filter schema.\r\n */\r\nexport interface SavedFilter {\r\n  id: string;\r\n  name?: string;\r\n  resourceKey?: string;\r\n  criteria?: Record<string, unknown>;\r\n  ownerId?: string;\r\n  isDefault?: boolean;\r\n  shared?: boolean;\r\n  createdAt?: string;\r\n  updatedAt?: string;\r\n}\r\n"],"mappings":"","ignoreList":[]}