@entifix/react-integration 0.1.0-0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r10c Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @entifix/react-integration
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test @entifix/react-integration` to execute the unit tests via [Vitest](https://vitest.dev/).

package/dist/context/adapters-context/adapters-context.d.ts

@@ -0,0 +1,4 @@
+import { type Context } from 'react';
+export declare function createAdaptersContext<TAdapters>(): Context<TAdapters>;
+export declare function useAdaptersContext<TAdapters>(context: Context<TAdapters>): TAdapters;
+//# sourceMappingURL=adapters-context.d.ts.map

package/dist/context/adapters-context/adapters-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters-context.d.ts","sourceRoot":"","sources":["../../../src/context/adapters-context/adapters-context.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAA6B,MAAM,OAAO,CAAC;AAEhE,wBAAgB,qBAAqB,CAAC,SAAS,wBAE9C;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,aAaxE"}

package/dist/context/adapters-context/adapters-context.js

@@ -0,0 +1,19 @@
+import { EntifixBuildError } from '@entifix/core';
+import { createContext, useContext } from 'react';
+export function createAdaptersContext() {
+    return /*#__PURE__*/ createContext({});
+}
+export function useAdaptersContext(context) {
+    const contextValue = useContext(context);
+    // The default `createAdaptersContext` hands out is `{}`, so "nobody mounted
+    // a provider" and "the object has no keys" are the same question. Asked
+    // directly rather than through a generic `isEmpty`: that helper also answers
+    // for strings, arrays and null, none of which can reach here, and it was the
+    // single import crossing out of entifix.
+    if (Object.keys(contextValue).length === 0) {
+        throw new EntifixBuildError('Adapters context is empty. Make sure to wrap your component tree with the appropriate AdaptersProvider.');
+    }
+    return contextValue;
+}
+
+//# sourceMappingURL=adapters-context.js.map

package/dist/context/adapters-context/adapters-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/context/adapters-context/adapters-context.tsx"],"sourcesContent":["import { EntifixBuildError } from '@entifix/core';\nimport { type Context, createContext, useContext } from 'react';\n\nexport function createAdaptersContext<TAdapters>() {\n  return createContext({} as TAdapters);\n}\n\nexport function useAdaptersContext<TAdapters>(context: Context<TAdapters>) {\n  const contextValue = useContext(context);\n  // The default `createAdaptersContext` hands out is `{}`, so \"nobody mounted\n  // a provider\" and \"the object has no keys\" are the same question. Asked\n  // directly rather than through a generic `isEmpty`: that helper also answers\n  // for strings, arrays and null, none of which can reach here, and it was the\n  // single import crossing out of entifix.\n  if (Object.keys(contextValue as object).length === 0) {\n    throw new EntifixBuildError(\n      'Adapters context is empty. Make sure to wrap your component tree with the appropriate AdaptersProvider.',\n    );\n  }\n  return contextValue;\n}\n"],"names":["EntifixBuildError","createContext","useContext","createAdaptersContext","useAdaptersContext","context","contextValue","Object","keys","length"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,gBAAgB;AAClD,SAAuBC,aAAa,EAAEC,UAAU,QAAQ,QAAQ;AAEhE,OAAO,SAASC;IACd,qBAAOF,cAAc,CAAC;AACxB;AAEA,OAAO,SAASG,mBAA8BC,OAA2B;IACvE,MAAMC,eAAeJ,WAAWG;IAChC,4EAA4E;IAC5E,wEAAwE;IACxE,6EAA6E;IAC7E,6EAA6E;IAC7E,yCAAyC;IACzC,IAAIE,OAAOC,IAAI,CAACF,cAAwBG,MAAM,KAAK,GAAG;QACpD,MAAM,IAAIT,kBACR;IAEJ;IACA,OAAOM;AACT"}

package/dist/context/adapters-context/index.d.ts

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

package/dist/context/adapters-context/index.d.ts.map

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

package/dist/context/adapters-context/index.js

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

package/dist/context/adapters-context/index.js.map

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

package/dist/hooks/use-data-loading/index.d.ts

@@ -0,0 +1,3 @@
+export * from './use-data-loading.js';
+export * from './use-data-loading.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/use-data-loading/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-data-loading/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC"}

package/dist/hooks/use-data-loading/index.js

@@ -0,0 +1,4 @@
+export * from './use-data-loading.js';
+export * from './use-data-loading.types.js';
+
+//# sourceMappingURL=index.js.map

package/dist/hooks/use-data-loading/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-data-loading/index.ts"],"sourcesContent":["export * from './use-data-loading.js';\nexport * from './use-data-loading.types.js';\n"],"names":[],"mappings":"AAAA,cAAc,wBAAwB;AACtC,cAAc,8BAA8B"}

package/dist/hooks/use-data-loading/use-data-loading.d.ts

@@ -0,0 +1,26 @@
+import { type EntifixError, type Entity, type EntitySorting, type FilterGroup } from '@entifix/core';
+import type { UseDataLoadingOptions } from './use-data-loading.types.js';
+/**
+ * Runs an entity list use-case and caches the result through TanStack Query.
+ *
+ * The reducer owns the *request* (page/size/filter/sort); `useQuery` owns the
+ * *fetch* — deduping, caching, and (with a shared `queryKey`) letting mutations
+ * and reactive events invalidate the list. The public shape is unchanged: the
+ * `uc`/`ctx` come in the same way and the Effect runs against the same provided
+ * Tags, so callers and organisms are untouched.
+ */
+export declare function useDataLoading<TEntity extends Entity, TContext>({ uc, ctx, initialPageSize, queryKey, enabled, baseFiltering, }: UseDataLoadingOptions<TEntity, TContext>): {
+    isLoading: boolean;
+    items: TEntity[];
+    totalItems: number;
+    currentPage: number;
+    pageSize: number;
+    error: EntifixError | undefined;
+    filtering: FilterGroup<TEntity> | undefined;
+    sorting: EntitySorting<TEntity> | undefined;
+    onPageChange: (newPage: number) => void;
+    onPageSizeChange: (newPageSize: number) => void;
+    onFilteringChange: (filtering: FilterGroup<TEntity>) => void;
+    onSortingChange: (sorting: EntitySorting<TEntity>) => void;
+};
+//# sourceMappingURL=use-data-loading.d.ts.map

package/dist/hooks/use-data-loading/use-data-loading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-loading.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-data-loading/use-data-loading.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,MAAM,EAGX,KAAK,aAAa,EAClB,KAAK,WAAW,EAGjB,MAAM,eAAe,CAAC;AAavB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAiCzE;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAS,MAAM,EAAE,QAAQ,EAAE,EAC/D,EAAE,EACF,GAAG,EACH,eAAmC,EACnC,QAAQ,EACR,OAAc,EACd,aAAa,GACd,EAAE,qBAAqB,CAAC,OAAO,EAAE,QAAQ,CAAC;;;;;;;;;4BA0GE,MAAM;oCAIE,MAAM;mCAMP,WAAW,CAAC,OAAO,CAAC;+BAIxB,aAAa,CAAC,OAAO,CAAC;EAkBrE"}

package/dist/hooks/use-data-loading/use-data-loading.js

@@ -0,0 +1,167 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { EntityLoadRequestTag } from '@entifix/business';
+import { serializeRsql, serializeSort } from '@entifix/core';
+import { keepPreviousData, useQuery } from '@tanstack/react-query';
+import { Context, Effect } from 'effect';
+import { useCallback, useEffect, useId, useMemo, useReducer, useRef } from 'react';
+import { combineFilterGroups } from '../../query/combine-filtering.js';
+const DEFAULT_PAGE_SIZE = 10;
+function requestReducer(state, action) {
+    return _extends({}, state, action.set);
+}
+function initialRequest(pageSize) {
+    return {
+        currentPage: 1,
+        pageSize,
+        filtering: undefined,
+        sorting: undefined
+    };
+}
+/**
+ * Runs an entity list use-case and caches the result through TanStack Query.
+ *
+ * The reducer owns the *request* (page/size/filter/sort); `useQuery` owns the
+ * *fetch* — deduping, caching, and (with a shared `queryKey`) letting mutations
+ * and reactive events invalidate the list. The public shape is unchanged: the
+ * `uc`/`ctx` come in the same way and the Effect runs against the same provided
+ * Tags, so callers and organisms are untouched.
+ */ export function useDataLoading({ uc, ctx, initialPageSize = DEFAULT_PAGE_SIZE, queryKey, enabled = true, baseFiltering }) {
+    var _ref, _ref1, _query_error;
+    var _query_data, _query_data1;
+    const [request, dispatch] = useReducer(requestReducer, initialPageSize, initialRequest);
+    // Callers rebuild `uc`/`ctx` inline every render, so hold the latest in refs
+    // and keep them out of the query key — keying on their identity would refetch
+    // on every render. Written in an effect (refs may not be set during render);
+    // effects fire in order, so the query below always reads the latest.
+    const ucRef = useRef(uc);
+    const ctxRef = useRef(ctx);
+    useEffect(()=>{
+        ucRef.current = uc;
+        ctxRef.current = ctx;
+    });
+    // What actually goes on the wire: the caller's standing restriction ANDed with
+    // whatever the user applied. Kept separate from `request.filtering` because the
+    // restriction is not the user's filter — the panel must keep showing only what
+    // they set, while the request keeps carrying both.
+    const effectiveFiltering = useMemo(()=>combineFilterGroups(baseFiltering, request.filtering), [
+        baseFiltering,
+        request.filtering
+    ]);
+    // The applied filter/sort are rebuilt each render, so their *serialized* form
+    // — the same codec the request needs anyway — is what keys the query: a stable
+    // string that changes exactly when the query does.
+    const rsql = useMemo(()=>serializeRsql(effectiveFiltering ? [
+            effectiveFiltering
+        ] : undefined), [
+        effectiveFiltering
+    ]);
+    const sort = useMemo(()=>serializeSort(request.sorting ? [
+            request.sorting
+        ] : undefined), [
+        request.sorting
+    ]);
+    const loadRequest = useMemo(()=>{
+        const built = {
+            page: request.currentPage,
+            pageSize: request.pageSize
+        };
+        // An empty group serializes to nothing; omit it rather than send a filter
+        // that matches everything.
+        if (rsql !== '' && effectiveFiltering) {
+            built.filtering = [
+                effectiveFiltering
+            ];
+        }
+        if (sort !== '' && request.sorting) {
+            built.sorting = [
+                request.sorting
+            ];
+        }
+        return built;
+    }, [
+        request.currentPage,
+        request.pageSize,
+        effectiveFiltering,
+        request.sorting,
+        rsql,
+        sort
+    ]);
+    // Falls back to a per-instance id so an un-scoped list never collides with
+    // another in the shared cache — correct, just unshared (see the type doc).
+    const instanceId = useId();
+    const scope = queryKey != null ? queryKey : [
+        instanceId
+    ];
+    const query = useQuery({
+        enabled,
+        /**
+     * Page, size, filter and sort are all part of the key, so every one of them
+     * is a *different* query — and without this, `data` goes undefined the
+     * instant any of them changes. The table would then see `items.length === 0`
+     * with `isFetching` true, read it as a first load, and blank populated rows
+     * to skeleton on every pagination click: the grey flash the loading contract
+     * exists to prevent. Keeping the previous page is what makes "skeleton only
+     * on first load" true rather than merely intended.
+     */ placeholderData: keepPreviousData,
+        queryKey: [
+            ...scope,
+            'load',
+            request.currentPage,
+            request.pageSize,
+            rsql,
+            sort
+        ],
+        queryFn: ()=>Effect.runPromise(Effect.provide(ucRef.current, ctxRef.current.pipe(Context.add(EntityLoadRequestTag, // The tag carries no generic, so the entity-typed request crosses
+            // it — the same cast `loadUCFactory` makes reading it back.
+            loadRequest))))
+    });
+    const onPageChange = useCallback((newPage)=>{
+        dispatch({
+            set: {
+                currentPage: newPage
+            }
+        });
+    }, []);
+    const onPageSizeChange = useCallback((newPageSize)=>{
+        dispatch({
+            set: {
+                pageSize: newPageSize,
+                currentPage: 1
+            }
+        });
+    }, []);
+    // Narrowing the result set invalidates the page number: page 4 of the old
+    // result is very likely past the end of the new one.
+    const onFilteringChange = useCallback((filtering)=>{
+        dispatch({
+            set: {
+                filtering,
+                currentPage: 1
+            }
+        });
+    }, []);
+    const onSortingChange = useCallback((sorting)=>{
+        dispatch({
+            set: {
+                sorting,
+                currentPage: 1
+            }
+        });
+    }, []);
+    return {
+        isLoading: query.isFetching,
+        items: (_ref = (_query_data = query.data) == null ? void 0 : _query_data.items) != null ? _ref : [],
+        totalItems: (_ref1 = (_query_data1 = query.data) == null ? void 0 : _query_data1.total) != null ? _ref1 : 0,
+        currentPage: request.currentPage,
+        pageSize: request.pageSize,
+        error: (_query_error = query.error) != null ? _query_error : undefined,
+        filtering: request.filtering,
+        sorting: request.sorting,
+        onPageChange,
+        onPageSizeChange,
+        onFilteringChange,
+        onSortingChange
+    };
+}
+
+//# sourceMappingURL=use-data-loading.js.map

package/dist/hooks/use-data-loading/use-data-loading.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-data-loading/use-data-loading.ts"],"sourcesContent":["import { EntityLoadRequestTag } from '@entifix/business';\nimport {\n  type EntifixError,\n  type Entity,\n  type EntityLoadRequest,\n  type EntityPage,\n  type EntitySorting,\n  type FilterGroup,\n  serializeRsql,\n  serializeSort,\n} from '@entifix/core';\nimport { keepPreviousData, useQuery } from '@tanstack/react-query';\nimport { Context, Effect } from 'effect';\nimport {\n  useCallback,\n  useEffect,\n  useId,\n  useMemo,\n  useReducer,\n  useRef,\n} from 'react';\n\nimport { combineFilterGroups } from '../../query/combine-filtering.js';\nimport type { UseDataLoadingOptions } from './use-data-loading.types.js';\n\nconst DEFAULT_PAGE_SIZE = 10;\n\n/**\n * The request the caller controls — page, size, and the *applied* filter/sort.\n * The response (items, loading, error) is owned by the query cache, not here.\n */\ninterface RequestState<T extends Entity> {\n  currentPage: number;\n  pageSize: number;\n  filtering: FilterGroup<T> | undefined;\n  sorting: EntitySorting<T> | undefined;\n}\n\ntype RequestAction<T extends Entity> = { set: Partial<RequestState<T>> };\n\nfunction requestReducer<T extends Entity>(\n  state: RequestState<T>,\n  action: RequestAction<T>,\n): RequestState<T> {\n  return { ...state, ...action.set };\n}\n\nfunction initialRequest<T extends Entity>(pageSize: number): RequestState<T> {\n  return {\n    currentPage: 1,\n    pageSize,\n    filtering: undefined,\n    sorting: undefined,\n  };\n}\n\n/**\n * Runs an entity list use-case and caches the result through TanStack Query.\n *\n * The reducer owns the *request* (page/size/filter/sort); `useQuery` owns the\n * *fetch* — deduping, caching, and (with a shared `queryKey`) letting mutations\n * and reactive events invalidate the list. The public shape is unchanged: the\n * `uc`/`ctx` come in the same way and the Effect runs against the same provided\n * Tags, so callers and organisms are untouched.\n */\nexport function useDataLoading<TEntity extends Entity, TContext>({\n  uc,\n  ctx,\n  initialPageSize = DEFAULT_PAGE_SIZE,\n  queryKey,\n  enabled = true,\n  baseFiltering,\n}: UseDataLoadingOptions<TEntity, TContext>) {\n  const [request, dispatch] = useReducer(\n    requestReducer as (\n      state: RequestState<TEntity>,\n      action: RequestAction<TEntity>,\n    ) => RequestState<TEntity>,\n    initialPageSize,\n    initialRequest<TEntity>,\n  );\n\n  // Callers rebuild `uc`/`ctx` inline every render, so hold the latest in refs\n  // and keep them out of the query key — keying on their identity would refetch\n  // on every render. Written in an effect (refs may not be set during render);\n  // effects fire in order, so the query below always reads the latest.\n  const ucRef = useRef(uc);\n  const ctxRef = useRef(ctx);\n  useEffect(() => {\n    ucRef.current = uc;\n    ctxRef.current = ctx;\n  });\n\n  // What actually goes on the wire: the caller's standing restriction ANDed with\n  // whatever the user applied. Kept separate from `request.filtering` because the\n  // restriction is not the user's filter — the panel must keep showing only what\n  // they set, while the request keeps carrying both.\n  const effectiveFiltering = useMemo(\n    () => combineFilterGroups<TEntity>(baseFiltering, request.filtering),\n    [baseFiltering, request.filtering],\n  );\n\n  // The applied filter/sort are rebuilt each render, so their *serialized* form\n  // — the same codec the request needs anyway — is what keys the query: a stable\n  // string that changes exactly when the query does.\n  const rsql = useMemo(\n    () => serializeRsql(effectiveFiltering ? [effectiveFiltering] : undefined),\n    [effectiveFiltering],\n  );\n  const sort = useMemo(\n    () => serializeSort(request.sorting ? [request.sorting] : undefined),\n    [request.sorting],\n  );\n\n  const loadRequest = useMemo<EntityLoadRequest<TEntity>>(() => {\n    const built: EntityLoadRequest<TEntity> = {\n      page: request.currentPage,\n      pageSize: request.pageSize,\n    };\n    // An empty group serializes to nothing; omit it rather than send a filter\n    // that matches everything.\n    if (rsql !== '' && effectiveFiltering) {\n      built.filtering = [effectiveFiltering];\n    }\n    if (sort !== '' && request.sorting) {\n      built.sorting = [request.sorting];\n    }\n    return built;\n  }, [\n    request.currentPage,\n    request.pageSize,\n    effectiveFiltering,\n    request.sorting,\n    rsql,\n    sort,\n  ]);\n\n  // Falls back to a per-instance id so an un-scoped list never collides with\n  // another in the shared cache — correct, just unshared (see the type doc).\n  const instanceId = useId();\n  const scope = queryKey ?? [instanceId];\n\n  const query = useQuery<EntityPage<TEntity>, EntifixError>({\n    enabled,\n    /**\n     * Page, size, filter and sort are all part of the key, so every one of them\n     * is a *different* query — and without this, `data` goes undefined the\n     * instant any of them changes. The table would then see `items.length === 0`\n     * with `isFetching` true, read it as a first load, and blank populated rows\n     * to skeleton on every pagination click: the grey flash the loading contract\n     * exists to prevent. Keeping the previous page is what makes \"skeleton only\n     * on first load\" true rather than merely intended.\n     */\n    placeholderData: keepPreviousData,\n    queryKey: [\n      ...scope,\n      'load',\n      request.currentPage,\n      request.pageSize,\n      rsql,\n      sort,\n    ],\n    queryFn: () =>\n      Effect.runPromise(\n        Effect.provide(\n          ucRef.current,\n          ctxRef.current.pipe(\n            Context.add(\n              EntityLoadRequestTag,\n              // The tag carries no generic, so the entity-typed request crosses\n              // it — the same cast `loadUCFactory` makes reading it back.\n              loadRequest as unknown as EntityLoadRequest,\n            ),\n          ),\n        ),\n      ),\n  });\n\n  const onPageChange = useCallback((newPage: number) => {\n    dispatch({ set: { currentPage: newPage } });\n  }, []);\n\n  const onPageSizeChange = useCallback((newPageSize: number) => {\n    dispatch({ set: { pageSize: newPageSize, currentPage: 1 } });\n  }, []);\n\n  // Narrowing the result set invalidates the page number: page 4 of the old\n  // result is very likely past the end of the new one.\n  const onFilteringChange = useCallback((filtering: FilterGroup<TEntity>) => {\n    dispatch({ set: { filtering, currentPage: 1 } });\n  }, []);\n\n  const onSortingChange = useCallback((sorting: EntitySorting<TEntity>) => {\n    dispatch({ set: { sorting, currentPage: 1 } });\n  }, []);\n\n  return {\n    isLoading: query.isFetching,\n    items: query.data?.items ?? ([] as Array<TEntity>),\n    totalItems: query.data?.total ?? 0,\n    currentPage: request.currentPage,\n    pageSize: request.pageSize,\n    error: query.error ?? undefined,\n    filtering: request.filtering,\n    sorting: request.sorting,\n    onPageChange,\n    onPageSizeChange,\n    onFilteringChange,\n    onSortingChange,\n  };\n}\n"],"names":["EntityLoadRequestTag","serializeRsql","serializeSort","keepPreviousData","useQuery","Context","Effect","useCallback","useEffect","useId","useMemo","useReducer","useRef","combineFilterGroups","DEFAULT_PAGE_SIZE","requestReducer","state","action","set","initialRequest","pageSize","currentPage","filtering","undefined","sorting","useDataLoading","uc","ctx","initialPageSize","queryKey","enabled","baseFiltering","query","request","dispatch","ucRef","ctxRef","current","effectiveFiltering","rsql","sort","loadRequest","built","page","instanceId","scope","placeholderData","queryFn","runPromise","provide","pipe","add","onPageChange","newPage","onPageSizeChange","newPageSize","onFilteringChange","onSortingChange","isLoading","isFetching","items","data","totalItems","total","error"],"mappings":";AAAA,SAASA,oBAAoB,QAAQ,oBAAoB;AACzD,SAOEC,aAAa,EACbC,aAAa,QACR,gBAAgB;AACvB,SAASC,gBAAgB,EAAEC,QAAQ,QAAQ,wBAAwB;AACnE,SAASC,OAAO,EAAEC,MAAM,QAAQ,SAAS;AACzC,SACEC,WAAW,EACXC,SAAS,EACTC,KAAK,EACLC,OAAO,EACPC,UAAU,EACVC,MAAM,QACD,QAAQ;AAEf,SAASC,mBAAmB,QAAQ,mCAAmC;AAGvE,MAAMC,oBAAoB;AAe1B,SAASC,eACPC,KAAsB,EACtBC,MAAwB;IAExB,OAAO,aAAKD,OAAUC,OAAOC,GAAG;AAClC;AAEA,SAASC,eAAiCC,QAAgB;IACxD,OAAO;QACLC,aAAa;QACbD;QACAE,WAAWC;QACXC,SAASD;IACX;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASE,eAAiD,EAC/DC,EAAE,EACFC,GAAG,EACHC,kBAAkBd,iBAAiB,EACnCe,QAAQ,EACRC,UAAU,IAAI,EACdC,aAAa,EAC4B;qBAkIhCC;QAJAA,aACKA;IA9Hd,MAAM,CAACC,SAASC,SAAS,GAAGvB,WAC1BI,gBAIAa,iBACAT;IAGF,6EAA6E;IAC7E,8EAA8E;IAC9E,6EAA6E;IAC7E,qEAAqE;IACrE,MAAMgB,QAAQvB,OAAOc;IACrB,MAAMU,SAASxB,OAAOe;IACtBnB,UAAU;QACR2B,MAAME,OAAO,GAAGX;QAChBU,OAAOC,OAAO,GAAGV;IACnB;IAEA,+EAA+E;IAC/E,gFAAgF;IAChF,+EAA+E;IAC/E,mDAAmD;IACnD,MAAMW,qBAAqB5B,QACzB,IAAMG,oBAA6BkB,eAAeE,QAAQX,SAAS,GACnE;QAACS;QAAeE,QAAQX,SAAS;KAAC;IAGpC,8EAA8E;IAC9E,+EAA+E;IAC/E,mDAAmD;IACnD,MAAMiB,OAAO7B,QACX,IAAMT,cAAcqC,qBAAqB;YAACA;SAAmB,GAAGf,YAChE;QAACe;KAAmB;IAEtB,MAAME,OAAO9B,QACX,IAAMR,cAAc+B,QAAQT,OAAO,GAAG;YAACS,QAAQT,OAAO;SAAC,GAAGD,YAC1D;QAACU,QAAQT,OAAO;KAAC;IAGnB,MAAMiB,cAAc/B,QAAoC;QACtD,MAAMgC,QAAoC;YACxCC,MAAMV,QAAQZ,WAAW;YACzBD,UAAUa,QAAQb,QAAQ;QAC5B;QACA,0EAA0E;QAC1E,2BAA2B;QAC3B,IAAImB,SAAS,MAAMD,oBAAoB;YACrCI,MAAMpB,SAAS,GAAG;gBAACgB;aAAmB;QACxC;QACA,IAAIE,SAAS,MAAMP,QAAQT,OAAO,EAAE;YAClCkB,MAAMlB,OAAO,GAAG;gBAACS,QAAQT,OAAO;aAAC;QACnC;QACA,OAAOkB;IACT,GAAG;QACDT,QAAQZ,WAAW;QACnBY,QAAQb,QAAQ;QAChBkB;QACAL,QAAQT,OAAO;QACfe;QACAC;KACD;IAED,2EAA2E;IAC3E,2EAA2E;IAC3E,MAAMI,aAAanC;IACnB,MAAMoC,QAAQhB,mBAAAA,WAAY;QAACe;KAAW;IAEtC,MAAMZ,QAAQ5B,SAA4C;QACxD0B;QACA;;;;;;;;KAQC,GACDgB,iBAAiB3C;QACjB0B,UAAU;eACLgB;YACH;YACAZ,QAAQZ,WAAW;YACnBY,QAAQb,QAAQ;YAChBmB;YACAC;SACD;QACDO,SAAS,IACPzC,OAAO0C,UAAU,CACf1C,OAAO2C,OAAO,CACZd,MAAME,OAAO,EACbD,OAAOC,OAAO,CAACa,IAAI,CACjB7C,QAAQ8C,GAAG,CACTnD,sBACA,kEAAkE;YAClE,4DAA4D;YAC5DyC;IAKZ;IAEA,MAAMW,eAAe7C,YAAY,CAAC8C;QAChCnB,SAAS;YAAEhB,KAAK;gBAAEG,aAAagC;YAAQ;QAAE;IAC3C,GAAG,EAAE;IAEL,MAAMC,mBAAmB/C,YAAY,CAACgD;QACpCrB,SAAS;YAAEhB,KAAK;gBAAEE,UAAUmC;gBAAalC,aAAa;YAAE;QAAE;IAC5D,GAAG,EAAE;IAEL,0EAA0E;IAC1E,qDAAqD;IACrD,MAAMmC,oBAAoBjD,YAAY,CAACe;QACrCY,SAAS;YAAEhB,KAAK;gBAAEI;gBAAWD,aAAa;YAAE;QAAE;IAChD,GAAG,EAAE;IAEL,MAAMoC,kBAAkBlD,YAAY,CAACiB;QACnCU,SAAS;YAAEhB,KAAK;gBAAEM;gBAASH,aAAa;YAAE;QAAE;IAC9C,GAAG,EAAE;IAEL,OAAO;QACLqC,WAAW1B,MAAM2B,UAAU;QAC3BC,KAAK,WAAE5B,cAAAA,MAAM6B,IAAI,qBAAV7B,YAAY4B,KAAK,mBAAK,EAAE;QAC/BE,UAAU,YAAE9B,eAAAA,MAAM6B,IAAI,qBAAV7B,aAAY+B,KAAK,oBAAI;QACjC1C,aAAaY,QAAQZ,WAAW;QAChCD,UAAUa,QAAQb,QAAQ;QAC1B4C,KAAK,GAAEhC,eAAAA,MAAMgC,KAAK,YAAXhC,eAAeT;QACtBD,WAAWW,QAAQX,SAAS;QAC5BE,SAASS,QAAQT,OAAO;QACxB4B;QACAE;QACAE;QACAC;IACF;AACF"}

package/dist/hooks/use-data-loading/use-data-loading.types.d.ts

@@ -0,0 +1,53 @@
+import { EntityLoadRequestTag } from '@entifix/business';
+import { EntifixError, Entity, EntityPage, EntitySorting, FilterGroup } from '@entifix/core';
+import { Context, Effect } from 'effect';
+export interface UseDataLoadingState<T extends Entity> {
+    isLoading: boolean;
+    items: Array<T>;
+    totalItems: number;
+    currentPage: number;
+    pageSize: number;
+    error: EntifixError | undefined;
+    /**
+     * The filtering and sorting currently *applied* — not a draft. The controls
+     * commit through `onFilteringChange`/`onSortingChange`, so every value here
+     * has already been requested from the server.
+     */
+    filtering: FilterGroup<T> | undefined;
+    sorting: EntitySorting<T> | undefined;
+}
+export type UseDataLoadingAction<T extends Entity> = {
+    set: Partial<UseDataLoadingState<T>>;
+};
+export interface UseDataLoadingOptions<TEntity extends Entity, TContext> {
+    uc: Effect.Effect<EntityPage<TEntity>, EntifixError, EntityLoadRequestTag | TContext>;
+    ctx: Context.Context<TContext>;
+    /**
+     * Page size for the first load; defaults to 10. Callers that need the whole
+     * set rather than a page — a relation picker, say — raise this.
+     */
+    initialPageSize?: number;
+    /**
+     * The stable prefix that scopes this list in the shared query cache — pass
+     * {@link entityQueryScope}`(Ctor)` so refetches, optimistic writes, and
+     * reactive invalidation of the same entity all address one cache entry.
+     * Omit it and the hook falls back to a per-instance id: correct in isolation
+     * (no cross-list collisions) but unshared, so nothing outside this hook can
+     * invalidate it.
+     */
+    queryKey?: ReadonlyArray<unknown>;
+    /**
+     * `false` holds the request back without unmounting the hook — what a picker's
+     * browse dialog needs, since a list nobody has opened yet must not be fetched.
+     * Defaults to `true`, so every existing caller loads on mount as before.
+     */
+    enabled?: boolean;
+    /**
+     * A standing restriction ANDed into every request and never shown in the filter
+     * panel — "these are the rows this caller may see at all", as opposed to the
+     * filter the user is editing. A link picker narrowing what may be assigned uses
+     * it; so would a listing scoped to one tenant.
+     */
+    baseFiltering?: FilterGroup<TEntity>;
+}
+//# sourceMappingURL=use-data-loading.types.d.ts.map

package/dist/hooks/use-data-loading/use-data-loading.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-loading.types.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-data-loading/use-data-loading.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EACL,YAAY,EACZ,MAAM,EACN,UAAU,EACV,aAAa,EACb,WAAW,EACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzC,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,MAAM;IACnD,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;IAChC;;;;OAIG;IACH,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACtC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;CACvC;AAED,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,IAAI;IACnD,GAAG,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,WAAW,qBAAqB,CAAC,OAAO,SAAS,MAAM,EAAE,QAAQ;IACrE,EAAE,EAAE,MAAM,CAAC,MAAM,CACf,UAAU,CAAC,OAAO,CAAC,EACnB,YAAY,EACZ,oBAAoB,GAAG,QAAQ,CAChC,CAAC;IACF,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC/B;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAClC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;CACtC"}

package/dist/hooks/use-data-loading/use-data-loading.types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=use-data-loading.types.js.map

package/dist/hooks/use-data-loading/use-data-loading.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-data-loading/use-data-loading.types.ts"],"sourcesContent":["import { EntityLoadRequestTag } from '@entifix/business';\nimport {\n  EntifixError,\n  Entity,\n  EntityPage,\n  EntitySorting,\n  FilterGroup,\n} from '@entifix/core';\nimport { Context, Effect } from 'effect';\n\nexport interface UseDataLoadingState<T extends Entity> {\n  isLoading: boolean;\n  items: Array<T>;\n  totalItems: number;\n  currentPage: number;\n  pageSize: number;\n  error: EntifixError | undefined;\n  /**\n   * The filtering and sorting currently *applied* — not a draft. The controls\n   * commit through `onFilteringChange`/`onSortingChange`, so every value here\n   * has already been requested from the server.\n   */\n  filtering: FilterGroup<T> | undefined;\n  sorting: EntitySorting<T> | undefined;\n}\n\nexport type UseDataLoadingAction<T extends Entity> = {\n  set: Partial<UseDataLoadingState<T>>;\n};\n\nexport interface UseDataLoadingOptions<TEntity extends Entity, TContext> {\n  uc: Effect.Effect<\n    EntityPage<TEntity>,\n    EntifixError,\n    EntityLoadRequestTag | TContext\n  >;\n  ctx: Context.Context<TContext>;\n  /**\n   * Page size for the first load; defaults to 10. Callers that need the whole\n   * set rather than a page — a relation picker, say — raise this.\n   */\n  initialPageSize?: number;\n  /**\n   * The stable prefix that scopes this list in the shared query cache — pass\n   * {@link entityQueryScope}`(Ctor)` so refetches, optimistic writes, and\n   * reactive invalidation of the same entity all address one cache entry.\n   * Omit it and the hook falls back to a per-instance id: correct in isolation\n   * (no cross-list collisions) but unshared, so nothing outside this hook can\n   * invalidate it.\n   */\n  queryKey?: ReadonlyArray<unknown>;\n  /**\n   * `false` holds the request back without unmounting the hook — what a picker's\n   * browse dialog needs, since a list nobody has opened yet must not be fetched.\n   * Defaults to `true`, so every existing caller loads on mount as before.\n   */\n  enabled?: boolean;\n  /**\n   * A standing restriction ANDed into every request and never shown in the filter\n   * panel — \"these are the rows this caller may see at all\", as opposed to the\n   * filter the user is editing. A link picker narrowing what may be assigned uses\n   * it; so would a listing scoped to one tenant.\n   */\n  baseFiltering?: FilterGroup<TEntity>;\n}\n"],"names":[],"mappings":"AA8BA,WAkCC"}

package/dist/hooks/use-entity-form/index.d.ts

@@ -0,0 +1,4 @@
+export * from './use-entity-form.helpers.js';
+export * from './use-entity-form.js';
+export * from './use-entity-form.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/use-entity-form/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-form/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC"}

package/dist/hooks/use-entity-form/index.js

@@ -0,0 +1,5 @@
+export * from './use-entity-form.helpers.js';
+export * from './use-entity-form.js';
+export * from './use-entity-form.types.js';
+
+//# sourceMappingURL=index.js.map

package/dist/hooks/use-entity-form/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-entity-form/index.ts"],"sourcesContent":["export * from './use-entity-form.helpers.js';\nexport * from './use-entity-form.js';\nexport * from './use-entity-form.types.js';\n"],"names":[],"mappings":"AAAA,cAAc,+BAA+B;AAC7C,cAAc,uBAAuB;AACrC,cAAc,6BAA6B"}

package/dist/hooks/use-entity-form/use-entity-form.d.ts

@@ -0,0 +1,31 @@
+import { type Entity } from '@entifix/core';
+import type { UseEntityFormOptions, UseEntityFormResult } from './use-entity-form.types.js';
+/**
+ * The write half of an entity form: holds the string draft and reports
+ * metadata-derived validation, the counterpart to {@link useEntityRecord}
+ * (which reads the record it seeds from).
+ *
+ * It stays out of the transport: it neither fetches nor saves. `onSubmit`
+ * receives the validated draft, and the per-entity wrapper reconstructs the
+ * domain entity and calls the mutation. The result plugs straight into the
+ * agnostic `EntityForm` (`values`/`onFieldChange`/`errors`/`onSubmit`).
+ *
+ * TanStack Form owns the draft and the submission lifecycle; that is an
+ * implementation detail, and the returned shape is deliberately the plain
+ * `values`/`errors`/`setField`/`submit`/`isDirty` facade so `EntityForm` — which
+ * renders native inputs and knows nothing about any form library — stays
+ * agnostic. Fields are therefore never registered through `form.Field`; a
+ * form-level validator reporting `{ fields }` reaches them anyway, because
+ * `FormApi` creates meta for any field name an error arrives for.
+ *
+ * `revalidateLogic` is what makes a pristine form quiet: nothing validates until
+ * the first submit, and every keystroke revalidates after it. Running one
+ * validator under a single cause also keeps a fixed field from holding a stale
+ * message left behind by another cause.
+ *
+ * The seed applies once, so a caller that loads its record after mount keys the
+ * form by the record id to reseed — the same convention `EntityForm`'s wrappers
+ * already follow.
+ */
+export declare function useEntityForm<TEntity extends Entity>({ entityConstructor, entity, draft, fields, schema, validate, validationMessages, translateKey, onSubmit, }: UseEntityFormOptions<TEntity>): UseEntityFormResult;
+//# sourceMappingURL=use-entity-form.d.ts.map

package/dist/hooks/use-entity-form/use-entity-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-form.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-form/use-entity-form.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,MAAM,EAIZ,MAAM,eAAe,CAAC;AAWvB,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,EAAE,EACpD,iBAAiB,EACjB,MAAM,EACN,KAAK,EACL,MAAM,EACN,MAAM,EACN,QAAQ,EACR,kBAAkB,EAClB,YAAY,EACZ,QAAQ,GACT,EAAE,oBAAoB,CAAC,OAAO,CAAC,GAAG,mBAAmB,CAyLrD"}

package/dist/hooks/use-entity-form/use-entity-form.helpers.d.ts

@@ -0,0 +1,136 @@
+import { type EntityDraft, type EntityDraftValue, type EntityFieldDescriptor, type StandardSchemaV1 } from '@entifix/core';
+/**
+ * The value a field seeds with from a record.
+ *
+ * A scalar seeds as a **string**: links with their foreign key(s), dates with a
+ * `yyyy-mm-dd` value a `date` input accepts, everything else stringified.
+ *
+ * The array branch is explicit rather than left to `String(raw)`, even though
+ * the two produce the same characters today. `String(['a','b'])` is `'a,b'` by
+ * way of `Array.prototype.toString`, which is an accident: it was doing the
+ * work of a `scalarCollection` seed before the type existed, and
+ * `reconstructEntity` was handing the same string straight back as a `string`.
+ * Both halves were wrong in the same direction, so the fixed-point spec could
+ * not see it. Now the join is declared here and the split is declared there,
+ * and they are inverses on purpose.
+ *
+ * A **`composition`** is the one member that does not seed as a string, because
+ * it has no lossless string form at all — its rows seed as row drafts, each
+ * with a freshly minted key. That key is the only thing here the record does not
+ * supply, and it is minted at seed time rather than at render so that the rows a
+ * form starts with are already addressable.
+ */
+export declare function seedFieldValue(descriptor: EntityFieldDescriptor, entity: unknown): EntityDraftValue;
+/** Builds the initial draft for a record (or an empty one for a create). */
+export declare function seedEntityDraft(descriptors: readonly EntityFieldDescriptor[], entity: unknown): EntityDraft;
+/**
+ * Restores a persisted draft **over** a freshly seeded one, rather than in place
+ * of it.
+ *
+ * A draft outlives the entity that wrote it — it sits in IndexedDB across
+ * refreshes and deployments — so the two can disagree by the time it comes back.
+ * Replacing the seed outright is how that disagreement becomes a bug the user
+ * sees: a member added since the draft was written has no entry, reaches the form
+ * engine as `undefined`, and its input flips from controlled to uncontrolled
+ * mid-render. A member since removed goes the other way, surviving as a value
+ * nothing renders and `reconstructEntity` cannot assign.
+ *
+ * So the seed decides the *keys* and the draft decides the *values*: a name the
+ * entity no longer declares is dropped, and a name it declares that the draft
+ * lacks keeps its seeded value.
+ *
+ * **A value is restored only in the shape its member can hold**, which is now
+ * two shapes rather than one. A scalar takes a string; a `composition` takes a
+ * readable row list. Anything else is dropped back to its seed — a member that
+ * changed type between the write and the read, or a row list from a build that
+ * did not carry keys, restores as the record's own value instead of as
+ * something no editor can render. This is per member, so one unreadable entry
+ * never costs the user the rest of the form.
+ *
+ * This is the shape guard at the one place the shape is actually known. The
+ * store-level version check (`drafts-state.ts`) can only decide that a whole
+ * generation of drafts is unreadable; it cannot know which members one entity
+ * declares.
+ */
+export declare function restoreEntityDraft(descriptors: readonly EntityFieldDescriptor[], seed: EntityDraft, persisted: EntityDraft | undefined): EntityDraft;
+/** The slice of a form field's state this module reads: its error list. */
+export interface FieldErrorMeta {
+    errors?: readonly unknown[];
+}
+/**
+ * Flattens the form engine's per-field state into the `name → message` map the
+ * agnostic `EntityForm` renders. Only the first message per field survives: a
+ * row shows one line, and the metadata rules already stop at the first failure.
+ *
+ * Kept structural rather than typed against the engine so the rest of this
+ * module stays independent of which form library backs the hook.
+ */
+export declare function readFieldErrors(fieldMeta: Partial<Record<string, FieldErrorMeta | undefined>>): Record<string, string>;
+/**
+ * The four metadata-derived messages, already localized. Taken as an argument
+ * rather than built here so this stays a pure function — and because the
+ * sentence cannot be assembled from a label plus a hardcoded suffix: word order
+ * differs between locales.
+ */
+export interface EntityDraftMessages {
+    required(field: string): string;
+    number(field: string): string;
+    date(field: string): string;
+    option(field: string): string;
+}
+/**
+ * Validates a draft against what the metadata implies — `required` members must
+ * be filled, and a filled `number`/`date`/`enum` must be well-formed. Read-only
+ * members are skipped entirely; a relation is checked for presence but never
+ * for format, since its draft value is a foreign key this side cannot resolve.
+ *
+ * Metadata is only the first of three rule sources; {@link composeEntityFormErrors}
+ * is what layers a schema and the caller's own rules over this.
+ */
+export declare function validateEntityDraft(descriptors: readonly EntityFieldDescriptor[], values: EntityDraft, messages: EntityDraftMessages): Record<string, string>;
+/**
+ * Runs a Standard Schema over the draft and sorts its issues into per-field
+ * messages plus a form-level one (an issue with no path — a cross-field rule).
+ *
+ * **Schemas are authored against the string draft**, so they coerce
+ * (`z.coerce.number()`) rather than expect typed values: the draft is what the
+ * inputs round-trip, and the same schema then validates exactly what the user
+ * sees. Only the first issue per field survives, matching how a row renders.
+ *
+ * Synchronous rules only. An async schema returns a Promise the form's
+ * synchronous validation pass cannot wait on, so it is rejected loudly rather
+ * than silently passing.
+ */
+export declare function readSchemaIssues(schema: StandardSchemaV1, values: EntityDraft, translateIssue: (message: string, field: string | undefined) => string): {
+    fields: Record<string, string>;
+    form?: string;
+};
+/** Everything {@link composeEntityFormErrors} needs to judge one draft. */
+export interface ComposeEntityFormErrorsOptions {
+    descriptors: readonly EntityFieldDescriptor[];
+    values: EntityDraft;
+    messages: EntityDraftMessages;
+    schema?: StandardSchemaV1;
+    translateIssue: (message: string, field: string | undefined) => string;
+    validate?: (values: EntityDraft) => Record<string, string>;
+}
+/**
+ * The single composition point for a draft's errors: metadata rules first, then
+ * the entity's schema, then the caller's `validate` callback. Later sources win
+ * on conflict, so a caller can always override a message it disagrees with.
+ */
+export declare function composeEntityFormErrors({ descriptors, values, messages, schema, translateIssue, validate, }: ComposeEntityFormErrorsOptions): {
+    fields: Record<string, string>;
+    form?: string;
+};
+/**
+ * What a caller who supplies no {@link ValidationMessages} gets: the catalog key
+ * itself, with the field appended.
+ *
+ * Honest rather than English — there is no catalog in this package to resolve
+ * against — and visible enough in a form that a host notices it has wired no
+ * copy. It sits beside the validator rather than in `.types.ts`, which this
+ * repository keeps type-only.
+ */
+export declare const DEFAULT_VALIDATION_MESSAGES: EntityDraftMessages;
+//# sourceMappingURL=use-entity-form.helpers.d.ts.map

package/dist/hooks/use-entity-form/use-entity-form.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-form.helpers.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-form/use-entity-form.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAU1B,KAAK,gBAAgB,EAEtB,MAAM,eAAe,CAAC;AAwCvB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,OAAO,GACd,gBAAgB,CAKlB;AAqDD,4EAA4E;AAC5E,wBAAgB,eAAe,CAC7B,WAAW,EAAE,SAAS,qBAAqB,EAAE,EAC7C,MAAM,EAAE,OAAO,GACd,WAAW,CAMb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,SAAS,qBAAqB,EAAE,EAC7C,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,WAAW,GAAG,SAAS,GACjC,WAAW,CAeb;AAED,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,CAAC,CAAC,GAC7D,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,SAAS,qBAAqB,EAAE,EAC7C,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,mBAAmB,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwBxB;AAkHD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,WAAW,EACnB,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,GACrE;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAuBnD;AAED,2EAA2E;AAC3E,MAAM,WAAW,8BAA8B;IAC7C,WAAW,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC9C,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,CAAC;IACvE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5D;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,WAAW,EACX,MAAM,EACN,QAAQ,EACR,MAAM,EACN,cAAc,EACd,QAAQ,GACT,EAAE,8BAA8B,GAAG;IAClC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAUA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAKzC,CAAC"}