@entifix/react-controls 0.1.0-0

package/dist/ui/organisms/entity-form/entity-form.types.d.ts

@@ -0,0 +1,151 @@
+import type { EntifixError, Entity, EntityConstructor, EntityDraft, EntityDraftValue, EntityFieldDescriptor, EntityLinkSource, EntityMetadataDocument } from '@entifix/core';
+import type { ReactNode } from 'react';
+/** Whether the form shows values as text (`read`) or as inputs (`edit`). */
+export type EntityFormMode = 'read' | 'edit';
+/** What a custom edit control for one field is handed. */
+export interface EntityFieldRenderContext {
+    draft: EntityDraft;
+    value: string;
+    setField: (name: string, value: EntityDraftValue) => void;
+    /** The id the field's label points at — put it on your control. */
+    id: string;
+}
+/**
+ * A field as the form finally renders it: the metadata descriptor plus the
+ * per-field overrides a caller supplied through an `<EntityField>` slot.
+ */
+export interface EntityFormField<TEntity extends Entity> extends EntityFieldDescriptor {
+    /** Replaces the default edit control. */
+    render?: (context: EntityFieldRenderContext) => ReactNode;
+    /** Replaces the default read display. */
+    readRender?: (entity: TEntity | undefined) => ReactNode;
+    /** True when the field has no backing entity member (slot-only field). */
+    virtual?: boolean;
+}
+export interface EntityFormProps<TEntity extends Entity> {
+    /** Metadata source. Fields, labels and types derive from its accessors. */
+    entityConstructor: EntityConstructor<TEntity>;
+    /** The record being viewed/edited. The read display and, in a wrapper, the
+     *  initial draft both come from it; omit for a create form. */
+    entity?: TEntity;
+    /** The current draft. The form is controlled — a host (the `useEntityForm`
+     *  hook or a `useState`) owns this and updates it via `onFieldChange`. */
+    values?: EntityDraft;
+    /**
+     * Called when one field changes.
+     *
+     * The value is a union rather than a string because a `composition`
+     * member's is its list of rows — the one member with no lossless string form.
+     * Every scalar editor still writes a string, so a host that only edits
+     * scalars is unaffected.
+     */
+    onFieldChange?: (name: string, value: EntityDraftValue) => void;
+    /**
+     * A search/browse source per reference, keyed by accessor name. A `link` field
+     * with a source gets the full editor; one without keeps its read-only display,
+     * which is what a form that only shows a relation still wants.
+     *
+     * A **`string`** field with a source gets the same editor, because a foreign
+     * key whose target lives in another slice's store cannot be a typed `link` at
+     * all and is a plain id member (ADR 0022). The editor does not know the
+     * difference — it writes the target's id into the draft either way.
+     *
+     * A key naming any other member throws: `linkCollection` has no editor
+     * anywhere yet, and a `boolean`/`enum`/`number`/`date` can never name another
+     * record, so the entry could only be dropped — and a dropped source looks
+     * exactly like a member the entity declared read-only.
+     *
+     * A registry rather than a slot per relation: the whole point is that an entity
+     * declaring a reference needs no bespoke control. The sources are built by the
+     * caller because fetching them is the integration layer's job, and this package
+     * cannot reach it.
+     */
+    linkSources?: Record<string, EntityLinkSource<any>>;
+    /**
+     * A relation was set or cleared. The instance travels alongside the id the
+     * draft holds, so a host can remember it — an id alone cannot be written as an
+     * embedded relation.
+     */
+    onLinkChange?: (name: string, entity: Entity | undefined) => void;
+    /** Force a mode. Omit to let the form own it (with the built-in toggle). */
+    mode?: EntityFormMode;
+    /** Initial mode when uncontrolled. Defaults to `read` with an `entity`, else
+     *  `edit` (a create form opens ready to type). */
+    defaultMode?: EntityFormMode;
+    onModeChange?: (mode: EntityFormMode) => void;
+    /** Per-field validation messages, keyed by field name. */
+    errors?: Record<string, string>;
+    /**
+     * A validation message that belongs to no single field — a rule spanning two
+     * of them. Rendered above the actions, since no row can host it.
+     */
+    formError?: string;
+    onSubmit?: (draft: EntityDraft) => void;
+    onDelete?: () => void;
+    /**
+     * What this caller may do with the entity, as served by
+     * `GET /api/<entity>/$metadata` and already filtered against the verified
+     * principal (ADR 0026).
+     *
+     * **Optional, and absent means "as before".** Without it the form renders Save
+     * and Delete exactly as it always has, so a call site that has not migrated is
+     * unaffected. This is not a security control — hiding a button protects
+     * nothing; the route guard does. It is what stops a screen offering an action
+     * the service will refuse.
+     */
+    metadata?: EntityMetadataDocument;
+    /** The document is still in flight; the action row renders as a skeleton. */
+    isMetadataLoading?: boolean;
+    /**
+     * A declared use case was invoked, by its `key`. The form renders the button
+     * and asks for confirmation where the descriptor says to; performing the act
+     * is the caller's — the browser must never import a use-case class.
+     */
+    onUseCase?: (key: string) => void;
+    /**
+     * Copies the record into a new draft, dropping the members declared
+     * `@accessor({ resetOnClone: true })` and always the id.
+     *
+     * A prop rather than something the form does by itself, because the *result*
+     * of a clone is a navigation — a create form holding the copy — and this
+     * package knows no router. The form supplies the cleaned draft
+     * (`cloneEntityDraft`); where it lands is the caller's.
+     *
+     * Absent renders no Clone action.
+     */
+    onClone?: (draft: EntityDraft) => void;
+    /**
+     * Render the **fields and nothing else** — no heading, no action row.
+     *
+     * For a form hosted inside something that already owns those controls: a
+     * wizard step sits under the wizard's own heading and advances with the
+     * wizard's own footer, so a second heading and a Save button beside Siguiente
+     * would be two controls for one job, and the Save would commit a partial
+     * record mid-flow.
+     *
+     * Opt-in and defaulted off, so every existing form is untouched.
+     */
+    embedded?: boolean;
+    isLoading?: boolean;
+    /**
+     * What holds the form's shape while the record is in flight.
+     *
+     * `true` (the default) renders the built-in placeholder — one label+control
+     * pair per resolved field, so the swap to the real rows shifts nothing. A node
+     * replaces that default; `false` renders no placeholder at all.
+     *
+     * The placeholder *replaces* the field rows; it never stacks above them.
+     */
+    skeleton?: boolean | ReactNode;
+    isSaving?: boolean;
+    isDeleting?: boolean;
+    /** The failure of the last load/save, shown as an alert. */
+    error?: EntifixError;
+    /** Link to return to, rendered as a `Back` action. Omit to hide it. */
+    backHref?: string;
+    /** Heading for the card. Defaults to a generic label. */
+    title?: ReactNode;
+    /** Customization slots — see `entity-form-slots`. */
+    children?: ReactNode;
+}
+//# sourceMappingURL=entity-form.types.d.ts.map

package/dist/ui/organisms/entity-form/entity-form.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-form.types.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/entity-form/entity-form.types.ts"],"names":[],"mappings":"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"}

package/dist/ui/organisms/entity-form/entity-form.types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=entity-form.types.js.map

package/dist/ui/organisms/entity-form/entity-form.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/entity-form/entity-form.types.ts"],"sourcesContent":["import type {\n  EntifixError,\n  Entity,\n  EntityConstructor,\n  EntityDraft,\n  EntityDraftValue,\n  EntityFieldDescriptor,\n  EntityLinkSource,\n  EntityMetadataDocument,\n} from '@entifix/core';\nimport type { ReactNode } from 'react';\n\n/** Whether the form shows values as text (`read`) or as inputs (`edit`). */\nexport type EntityFormMode = 'read' | 'edit';\n\n/** What a custom edit control for one field is handed. */\nexport interface EntityFieldRenderContext {\n  draft: EntityDraft;\n  value: string;\n  setField: (name: string, value: EntityDraftValue) => void;\n  /** The id the field's label points at — put it on your control. */\n  id: string;\n}\n\n/**\n * A field as the form finally renders it: the metadata descriptor plus the\n * per-field overrides a caller supplied through an `<EntityField>` slot.\n */\nexport interface EntityFormField<\n  TEntity extends Entity,\n> extends EntityFieldDescriptor {\n  /** Replaces the default edit control. */\n  render?: (context: EntityFieldRenderContext) => ReactNode;\n  /** Replaces the default read display. */\n  readRender?: (entity: TEntity | undefined) => ReactNode;\n  /** True when the field has no backing entity member (slot-only field). */\n  virtual?: boolean;\n}\n\nexport interface EntityFormProps<TEntity extends Entity> {\n  /** Metadata source. Fields, labels and types derive from its accessors. */\n  entityConstructor: EntityConstructor<TEntity>;\n  /** The record being viewed/edited. The read display and, in a wrapper, the\n   *  initial draft both come from it; omit for a create form. */\n  entity?: TEntity;\n\n  /** The current draft. The form is controlled — a host (the `useEntityForm`\n   *  hook or a `useState`) owns this and updates it via `onFieldChange`. */\n  values?: EntityDraft;\n  /**\n   * Called when one field changes.\n   *\n   * The value is a union rather than a string because a `composition`\n   * member's is its list of rows — the one member with no lossless string form.\n   * Every scalar editor still writes a string, so a host that only edits\n   * scalars is unaffected.\n   */\n  onFieldChange?: (name: string, value: EntityDraftValue) => void;\n\n  /**\n   * A search/browse source per reference, keyed by accessor name. A `link` field\n   * with a source gets the full editor; one without keeps its read-only display,\n   * which is what a form that only shows a relation still wants.\n   *\n   * A **`string`** field with a source gets the same editor, because a foreign\n   * key whose target lives in another slice's store cannot be a typed `link` at\n   * all and is a plain id member (ADR 0022). The editor does not know the\n   * difference — it writes the target's id into the draft either way.\n   *\n   * A key naming any other member throws: `linkCollection` has no editor\n   * anywhere yet, and a `boolean`/`enum`/`number`/`date` can never name another\n   * record, so the entry could only be dropped — and a dropped source looks\n   * exactly like a member the entity declared read-only.\n   *\n   * A registry rather than a slot per relation: the whole point is that an entity\n   * declaring a reference needs no bespoke control. The sources are built by the\n   * caller because fetching them is the integration layer's job, and this package\n   * cannot reach it.\n   */\n  // A source's target is another entity entirely, so it cannot be expressed in\n  // terms of `TEntity`; the input it feeds is instantiated per field anyway.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  linkSources?: Record<string, EntityLinkSource<any>>;\n  /**\n   * A relation was set or cleared. The instance travels alongside the id the\n   * draft holds, so a host can remember it — an id alone cannot be written as an\n   * embedded relation.\n   */\n  onLinkChange?: (name: string, entity: Entity | undefined) => void;\n\n  /** Force a mode. Omit to let the form own it (with the built-in toggle). */\n  mode?: EntityFormMode;\n  /** Initial mode when uncontrolled. Defaults to `read` with an `entity`, else\n   *  `edit` (a create form opens ready to type). */\n  defaultMode?: EntityFormMode;\n  onModeChange?: (mode: EntityFormMode) => void;\n\n  /** Per-field validation messages, keyed by field name. */\n  errors?: Record<string, string>;\n  /**\n   * A validation message that belongs to no single field — a rule spanning two\n   * of them. Rendered above the actions, since no row can host it.\n   */\n  formError?: string;\n\n  onSubmit?: (draft: EntityDraft) => void;\n  onDelete?: () => void;\n\n  /**\n   * What this caller may do with the entity, as served by\n   * `GET /api/<entity>/$metadata` and already filtered against the verified\n   * principal (ADR 0026).\n   *\n   * **Optional, and absent means \"as before\".** Without it the form renders Save\n   * and Delete exactly as it always has, so a call site that has not migrated is\n   * unaffected. This is not a security control — hiding a button protects\n   * nothing; the route guard does. It is what stops a screen offering an action\n   * the service will refuse.\n   */\n  metadata?: EntityMetadataDocument;\n  /** The document is still in flight; the action row renders as a skeleton. */\n  isMetadataLoading?: boolean;\n  /**\n   * A declared use case was invoked, by its `key`. The form renders the button\n   * and asks for confirmation where the descriptor says to; performing the act\n   * is the caller's — the browser must never import a use-case class.\n   */\n  onUseCase?: (key: string) => void;\n\n  /**\n   * Copies the record into a new draft, dropping the members declared\n   * `@accessor({ resetOnClone: true })` and always the id.\n   *\n   * A prop rather than something the form does by itself, because the *result*\n   * of a clone is a navigation — a create form holding the copy — and this\n   * package knows no router. The form supplies the cleaned draft\n   * (`cloneEntityDraft`); where it lands is the caller's.\n   *\n   * Absent renders no Clone action.\n   */\n  onClone?: (draft: EntityDraft) => void;\n\n  /**\n   * Render the **fields and nothing else** — no heading, no action row.\n   *\n   * For a form hosted inside something that already owns those controls: a\n   * wizard step sits under the wizard's own heading and advances with the\n   * wizard's own footer, so a second heading and a Save button beside Siguiente\n   * would be two controls for one job, and the Save would commit a partial\n   * record mid-flow.\n   *\n   * Opt-in and defaulted off, so every existing form is untouched.\n   */\n  embedded?: boolean;\n  isLoading?: boolean;\n  /**\n   * What holds the form's shape while the record is in flight.\n   *\n   * `true` (the default) renders the built-in placeholder — one label+control\n   * pair per resolved field, so the swap to the real rows shifts nothing. A node\n   * replaces that default; `false` renders no placeholder at all.\n   *\n   * The placeholder *replaces* the field rows; it never stacks above them.\n   */\n  skeleton?: boolean | ReactNode;\n  isSaving?: boolean;\n  isDeleting?: boolean;\n  /** The failure of the last load/save, shown as an alert. */\n  error?: EntifixError;\n\n  /** Link to return to, rendered as a `Back` action. Omit to hide it. */\n  backHref?: string;\n  /** Heading for the card. Defaults to a generic label. */\n  title?: ReactNode;\n\n  /** Customization slots — see `entity-form-slots`. */\n  children?: ReactNode;\n}\n"],"names":[],"mappings":"AAuCA,WA0IC"}

package/dist/ui/organisms/entity-form/index.d.ts

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

package/dist/ui/organisms/entity-form/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/entity-form/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC"}

package/dist/ui/organisms/entity-form/index.js

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

package/dist/ui/organisms/entity-form/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/entity-form/index.ts"],"sourcesContent":["export * from './entity-form.js';\nexport * from './entity-form.types.js';\nexport * from './entity-form-slots.js';\nexport * from './use-entity-form-fields.js';\n"],"names":[],"mappings":"AAAA,cAAc,mBAAmB;AACjC,cAAc,yBAAyB;AACvC,cAAc,yBAAyB;AACvC,cAAc,8BAA8B"}

package/dist/ui/organisms/entity-form/use-entity-form-fields.d.ts

@@ -0,0 +1,13 @@
+import type { Entity } from '@entifix/core';
+import type { EntityFormField } from './entity-form.types.js';
+import type { EntityFieldSlotProps } from './entity-form-slots.js';
+/**
+ * The field pipeline as a pure function — metadata descriptors, then
+ * `<EntityField>` overrides, then declared order. Kept separate from the
+ * component so the resolution rules can be tested without React.
+ *
+ * A slot naming a member the entity does not have becomes a virtual field (a
+ * computed one); a slot with `hidden` drops its field.
+ */
+export declare function resolveEntityFormFields<TEntity extends Entity>(described: Array<EntityFormField<TEntity>>, slotFields: Array<EntityFieldSlotProps<TEntity>>): Array<EntityFormField<TEntity>>;
+//# sourceMappingURL=use-entity-form-fields.d.ts.map

package/dist/ui/organisms/entity-form/use-entity-form-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-form-fields.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/entity-form/use-entity-form-fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,SAAS,MAAM,EAC5D,SAAS,EAAE,KAAK,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,EAC1C,UAAU,EAAE,KAAK,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,GAC/C,KAAK,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAgDjC"}

package/dist/ui/organisms/entity-form/use-entity-form-fields.js

@@ -0,0 +1,50 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+/**
+ * The field pipeline as a pure function — metadata descriptors, then
+ * `<EntityField>` overrides, then declared order. Kept separate from the
+ * component so the resolution rules can be tested without React.
+ *
+ * A slot naming a member the entity does not have becomes a virtual field (a
+ * computed one); a slot with `hidden` drops its field.
+ */ export function resolveEntityFormFields(described, slotFields) {
+    const hidden = new Set(slotFields.filter((slot)=>slot.hidden).map((slot)=>slot.field));
+    const merged = described.filter((field)=>!hidden.has(field.name)).map((field)=>{
+        const slot = slotFields.find((entry)=>entry.field === field.name);
+        if (!slot) return field;
+        const { field: _field, hidden: _hidden } = slot, overrides = _object_without_properties_loose(slot, [
+            "field",
+            "hidden"
+        ]);
+        return _extends({}, field, Object.fromEntries(Object.entries(overrides).filter(([, value])=>value !== undefined)));
+    });
+    const virtual = slotFields.filter((slot)=>!slot.hidden && !described.some((field)=>field.name === slot.field)).map((slot, index)=>{
+        var _slot_label, _slot_order;
+        return {
+            name: slot.field,
+            key: slot.field,
+            label: (_slot_label = slot.label) != null ? _slot_label : slot.field,
+            type: 'string',
+            sortable: false,
+            filterable: false,
+            order: (_slot_order = slot.order) != null ? _slot_order : described.length + index,
+            readonly: false,
+            required: false,
+            linkLabelProperty: 'name',
+            linkSearchProperty: 'name',
+            linkSerialization: 'id',
+            // A slot-only column has no accessor, so there is nothing for a copy to
+            // reset — the value is computed from members that are cloned themselves.
+            resetOnClone: false,
+            render: slot.render,
+            readRender: slot.readRender,
+            virtual: true
+        };
+    });
+    return [
+        ...merged,
+        ...virtual
+    ].sort((left, right)=>left.order - right.order);
+}
+
+//# sourceMappingURL=use-entity-form-fields.js.map

package/dist/ui/organisms/entity-form/use-entity-form-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/entity-form/use-entity-form-fields.ts"],"sourcesContent":["import type { Entity } from '@entifix/core';\n\nimport type { EntityFormField } from './entity-form.types.js';\nimport type { EntityFieldSlotProps } from './entity-form-slots.js';\n\n/**\n * The field pipeline as a pure function — metadata descriptors, then\n * `<EntityField>` overrides, then declared order. Kept separate from the\n * component so the resolution rules can be tested without React.\n *\n * A slot naming a member the entity does not have becomes a virtual field (a\n * computed one); a slot with `hidden` drops its field.\n */\nexport function resolveEntityFormFields<TEntity extends Entity>(\n  described: Array<EntityFormField<TEntity>>,\n  slotFields: Array<EntityFieldSlotProps<TEntity>>,\n): Array<EntityFormField<TEntity>> {\n  const hidden = new Set(\n    slotFields.filter(slot => slot.hidden).map(slot => slot.field),\n  );\n\n  const merged = described\n    .filter(field => !hidden.has(field.name))\n    .map(field => {\n      const slot = slotFields.find(entry => entry.field === field.name);\n      if (!slot) return field;\n      const { field: _field, hidden: _hidden, ...overrides } = slot;\n      return {\n        ...field,\n        ...Object.fromEntries(\n          Object.entries(overrides).filter(([, value]) => value !== undefined),\n        ),\n      } as EntityFormField<TEntity>;\n    });\n\n  const virtual = slotFields\n    .filter(\n      slot =>\n        !slot.hidden && !described.some(field => field.name === slot.field),\n    )\n    .map<EntityFormField<TEntity>>((slot, index) => ({\n      name: slot.field,\n      key: slot.field,\n      label: slot.label ?? slot.field,\n      type: 'string',\n      sortable: false,\n      filterable: false,\n      order: slot.order ?? described.length + index,\n      readonly: false,\n      required: false,\n      linkLabelProperty: 'name',\n      linkSearchProperty: 'name',\n      linkSerialization: 'id',\n      // A slot-only column has no accessor, so there is nothing for a copy to\n      // reset — the value is computed from members that are cloned themselves.\n      resetOnClone: false,\n      render: slot.render,\n      readRender: slot.readRender,\n      virtual: true,\n    }));\n\n  return [...merged, ...virtual].sort(\n    (left, right) => left.order - right.order,\n  );\n}\n"],"names":["resolveEntityFormFields","described","slotFields","hidden","Set","filter","slot","map","field","merged","has","name","find","entry","_field","_hidden","overrides","Object","fromEntries","entries","value","undefined","virtual","some","index","key","label","type","sortable","filterable","order","length","readonly","required","linkLabelProperty","linkSearchProperty","linkSerialization","resetOnClone","render","readRender","sort","left","right"],"mappings":";;AAKA;;;;;;;CAOC,GACD,OAAO,SAASA,wBACdC,SAA0C,EAC1CC,UAAgD;IAEhD,MAAMC,SAAS,IAAIC,IACjBF,WAAWG,MAAM,CAACC,CAAAA,OAAQA,KAAKH,MAAM,EAAEI,GAAG,CAACD,CAAAA,OAAQA,KAAKE,KAAK;IAG/D,MAAMC,SAASR,UACZI,MAAM,CAACG,CAAAA,QAAS,CAACL,OAAOO,GAAG,CAACF,MAAMG,IAAI,GACtCJ,GAAG,CAACC,CAAAA;QACH,MAAMF,OAAOJ,WAAWU,IAAI,CAACC,CAAAA,QAASA,MAAML,KAAK,KAAKA,MAAMG,IAAI;QAChE,IAAI,CAACL,MAAM,OAAOE;QAClB,MAAM,EAAEA,OAAOM,MAAM,EAAEX,QAAQY,OAAO,EAAgB,GAAGT,MAAdU,6CAAcV;;;;QACzD,OAAO,aACFE,OACAS,OAAOC,WAAW,CACnBD,OAAOE,OAAO,CAACH,WAAWX,MAAM,CAAC,CAAC,GAAGe,MAAM,GAAKA,UAAUC;IAGhE;IAEF,MAAMC,UAAUpB,WACbG,MAAM,CACLC,CAAAA,OACE,CAACA,KAAKH,MAAM,IAAI,CAACF,UAAUsB,IAAI,CAACf,CAAAA,QAASA,MAAMG,IAAI,KAAKL,KAAKE,KAAK,GAErED,GAAG,CAA2B,CAACD,MAAMkB;YAG7BlB,aAIAA;eAPwC;YAC/CK,MAAML,KAAKE,KAAK;YAChBiB,KAAKnB,KAAKE,KAAK;YACfkB,KAAK,GAAEpB,cAAAA,KAAKoB,KAAK,YAAVpB,cAAcA,KAAKE,KAAK;YAC/BmB,MAAM;YACNC,UAAU;YACVC,YAAY;YACZC,KAAK,GAAExB,cAAAA,KAAKwB,KAAK,YAAVxB,cAAcL,UAAU8B,MAAM,GAAGP;YACxCQ,UAAU;YACVC,UAAU;YACVC,mBAAmB;YACnBC,oBAAoB;YACpBC,mBAAmB;YACnB,wEAAwE;YACxE,yEAAyE;YACzEC,cAAc;YACdC,QAAQhC,KAAKgC,MAAM;YACnBC,YAAYjC,KAAKiC,UAAU;YAC3BjB,SAAS;QACX;;IAEF,OAAO;WAAIb;WAAWa;KAAQ,CAACkB,IAAI,CACjC,CAACC,MAAMC,QAAUD,KAAKX,KAAK,GAAGY,MAAMZ,KAAK;AAE7C"}

package/dist/ui/organisms/entity-table/entity-table-slots.d.ts

@@ -0,0 +1,55 @@
+import type { Entity, MetaAccessorType } from '@entifix/core';
+import { type ReactNode } from 'react';
+import type { EntityTableColumn } from './entity-table.types.js';
+/**
+ * The declarative customization API. Slots are configuration expressed as JSX:
+ * they never render themselves — `EntityTable` reads their props and decides
+ * where the configuration applies. That keeps simple tables to a single
+ * self-closing tag while complex ones stay declarative instead of drowning in
+ * option objects.
+ */
+export interface EntityColumnProps<TEntity extends Entity = Entity> {
+    /** Accessor name. Unknown names create an extra, entity-less column. */
+    field: string;
+    label?: string;
+    header?: ReactNode;
+    type?: MetaAccessorType;
+    order?: number;
+    sortable?: boolean;
+    filterable?: boolean;
+    render?: (item: TEntity) => ReactNode;
+}
+/** Overrides one metadata-derived column, or adds a computed one. */
+export declare function EntityColumn<TEntity extends Entity = Entity>(_props: EntityColumnProps<TEntity>): ReactNode;
+export interface EntityTableHeaderProps<TEntity extends Entity = Entity> {
+    /** Replaces the whole header row. Receives the resolved visible columns. */
+    render: (columns: Array<EntityTableColumn<TEntity>>) => ReactNode;
+}
+export declare function EntityTableHeader<TEntity extends Entity = Entity>(_props: EntityTableHeaderProps<TEntity>): ReactNode;
+export interface EntityTableRowProps<TEntity extends Entity = Entity> {
+    /** Replaces the whole body row for every item. */
+    render: (item: TEntity, columns: Array<EntityTableColumn<TEntity>>) => ReactNode;
+}
+export declare function EntityTableRow<TEntity extends Entity = Entity>(_props: EntityTableRowProps<TEntity>): ReactNode;
+export interface EntityTableToolbarProps {
+    children?: ReactNode;
+}
+/** Extra actions placed alongside the built-in toolbar controls. */
+export declare function EntityTableToolbar(_props: EntityTableToolbarProps): ReactNode;
+export interface EntityTableSlots<TEntity extends Entity> {
+    columns: Array<EntityColumnProps<TEntity>>;
+    header?: EntityTableHeaderProps<TEntity>;
+    row?: EntityTableRowProps<TEntity>;
+    toolbar?: ReactNode;
+    /** Children that matched no slot — rendered below the table untouched. */
+    rest: ReactNode[];
+}
+/**
+ * Sorts children into slots.
+ *
+ * Matching is by component identity rather than by `displayName`: identity
+ * survives minification and cannot collide with an unrelated component that
+ * happens to share a name.
+ */
+export declare function readEntityTableSlots<TEntity extends Entity>(children: ReactNode): EntityTableSlots<TEntity>;
+//# sourceMappingURL=entity-table-slots.d.ts.map

package/dist/ui/organisms/entity-table/entity-table-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-table-slots.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/entity-table/entity-table-slots.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAA4B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;;GAMG;AAEH,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM;IAChE,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,SAAS,CAAC;CACvC;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAC1D,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACjC,SAAS,CAEX;AAED,MAAM,WAAW,sBAAsB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM;IACrE,4EAA4E;IAC5E,MAAM,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,KAAK,SAAS,CAAC;CACnE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/D,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,GACtC,SAAS,CAEX;AAED,MAAM,WAAW,mBAAmB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM;IAClE,kDAAkD;IAClD,MAAM,EAAE,CACN,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,KACvC,SAAS,CAAC;CAChB;AAED,wBAAgB,cAAc,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAC5D,MAAM,EAAE,mBAAmB,CAAC,OAAO,CAAC,GACnC,SAAS,CAEX;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,uBAAuB,GAAG,SAAS,CAE7E;AAED,MAAM,WAAW,gBAAgB,CAAC,OAAO,SAAS,MAAM;IACtD,OAAO,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3C,MAAM,CAAC,EAAE,sBAAsB,CAAC,OAAO,CAAC,CAAC;IACzC,GAAG,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,0EAA0E;IAC1E,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,MAAM,EACzD,QAAQ,EAAE,SAAS,GAClB,gBAAgB,CAAC,OAAO,CAAC,CA4B3B"}

package/dist/ui/organisms/entity-table/entity-table-slots.js

@@ -0,0 +1,50 @@
+import { Children, isValidElement } from 'react';
+/** Overrides one metadata-derived column, or adds a computed one. */ export function EntityColumn(_props) {
+    return null;
+}
+export function EntityTableHeader(_props) {
+    return null;
+}
+export function EntityTableRow(_props) {
+    return null;
+}
+/** Extra actions placed alongside the built-in toolbar controls. */ export function EntityTableToolbar(_props) {
+    return null;
+}
+/**
+ * Sorts children into slots.
+ *
+ * Matching is by component identity rather than by `displayName`: identity
+ * survives minification and cannot collide with an unrelated component that
+ * happens to share a name.
+ */ export function readEntityTableSlots(children) {
+    const slots = {
+        columns: [],
+        rest: []
+    };
+    Children.toArray(children).forEach((child)=>{
+        if (!/*#__PURE__*/ isValidElement(child)) {
+            slots.rest.push(child);
+            return;
+        }
+        switch(child.type){
+            case EntityColumn:
+                slots.columns.push(child.props);
+                break;
+            case EntityTableHeader:
+                slots.header = child.props;
+                break;
+            case EntityTableRow:
+                slots.row = child.props;
+                break;
+            case EntityTableToolbar:
+                slots.toolbar = child.props.children;
+                break;
+            default:
+                slots.rest.push(child);
+        }
+    });
+    return slots;
+}
+
+//# sourceMappingURL=entity-table-slots.js.map

package/dist/ui/organisms/entity-table/entity-table-slots.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/entity-table/entity-table-slots.tsx"],"sourcesContent":["import type { Entity, MetaAccessorType } from '@entifix/core';\nimport { Children, isValidElement, type ReactNode } from 'react';\n\nimport type { EntityTableColumn } from './entity-table.types.js';\n\n/**\n * The declarative customization API. Slots are configuration expressed as JSX:\n * they never render themselves — `EntityTable` reads their props and decides\n * where the configuration applies. That keeps simple tables to a single\n * self-closing tag while complex ones stay declarative instead of drowning in\n * option objects.\n */\n\nexport interface EntityColumnProps<TEntity extends Entity = Entity> {\n  /** Accessor name. Unknown names create an extra, entity-less column. */\n  field: string;\n  label?: string;\n  header?: ReactNode;\n  type?: MetaAccessorType;\n  order?: number;\n  sortable?: boolean;\n  filterable?: boolean;\n  render?: (item: TEntity) => ReactNode;\n}\n\n/** Overrides one metadata-derived column, or adds a computed one. */\nexport function EntityColumn<TEntity extends Entity = Entity>(\n  _props: EntityColumnProps<TEntity>,\n): ReactNode {\n  return null;\n}\n\nexport interface EntityTableHeaderProps<TEntity extends Entity = Entity> {\n  /** Replaces the whole header row. Receives the resolved visible columns. */\n  render: (columns: Array<EntityTableColumn<TEntity>>) => ReactNode;\n}\n\nexport function EntityTableHeader<TEntity extends Entity = Entity>(\n  _props: EntityTableHeaderProps<TEntity>,\n): ReactNode {\n  return null;\n}\n\nexport interface EntityTableRowProps<TEntity extends Entity = Entity> {\n  /** Replaces the whole body row for every item. */\n  render: (\n    item: TEntity,\n    columns: Array<EntityTableColumn<TEntity>>,\n  ) => ReactNode;\n}\n\nexport function EntityTableRow<TEntity extends Entity = Entity>(\n  _props: EntityTableRowProps<TEntity>,\n): ReactNode {\n  return null;\n}\n\nexport interface EntityTableToolbarProps {\n  children?: ReactNode;\n}\n\n/** Extra actions placed alongside the built-in toolbar controls. */\nexport function EntityTableToolbar(_props: EntityTableToolbarProps): ReactNode {\n  return null;\n}\n\nexport interface EntityTableSlots<TEntity extends Entity> {\n  columns: Array<EntityColumnProps<TEntity>>;\n  header?: EntityTableHeaderProps<TEntity>;\n  row?: EntityTableRowProps<TEntity>;\n  toolbar?: ReactNode;\n  /** Children that matched no slot — rendered below the table untouched. */\n  rest: ReactNode[];\n}\n\n/**\n * Sorts children into slots.\n *\n * Matching is by component identity rather than by `displayName`: identity\n * survives minification and cannot collide with an unrelated component that\n * happens to share a name.\n */\nexport function readEntityTableSlots<TEntity extends Entity>(\n  children: ReactNode,\n): EntityTableSlots<TEntity> {\n  const slots: EntityTableSlots<TEntity> = { columns: [], rest: [] };\n\n  Children.toArray(children).forEach(child => {\n    if (!isValidElement(child)) {\n      slots.rest.push(child);\n      return;\n    }\n\n    switch (child.type) {\n      case EntityColumn:\n        slots.columns.push(child.props as EntityColumnProps<TEntity>);\n        break;\n      case EntityTableHeader:\n        slots.header = child.props as EntityTableHeaderProps<TEntity>;\n        break;\n      case EntityTableRow:\n        slots.row = child.props as EntityTableRowProps<TEntity>;\n        break;\n      case EntityTableToolbar:\n        slots.toolbar = (child.props as EntityTableToolbarProps).children;\n        break;\n      default:\n        slots.rest.push(child);\n    }\n  });\n\n  return slots;\n}\n"],"names":["Children","isValidElement","EntityColumn","_props","EntityTableHeader","EntityTableRow","EntityTableToolbar","readEntityTableSlots","children","slots","columns","rest","toArray","forEach","child","push","type","props","header","row","toolbar"],"mappings":"AACA,SAASA,QAAQ,EAAEC,cAAc,QAAwB,QAAQ;AAwBjE,mEAAmE,GACnE,OAAO,SAASC,aACdC,MAAkC;IAElC,OAAO;AACT;AAOA,OAAO,SAASC,kBACdD,MAAuC;IAEvC,OAAO;AACT;AAUA,OAAO,SAASE,eACdF,MAAoC;IAEpC,OAAO;AACT;AAMA,kEAAkE,GAClE,OAAO,SAASG,mBAAmBH,MAA+B;IAChE,OAAO;AACT;AAWA;;;;;;CAMC,GACD,OAAO,SAASI,qBACdC,QAAmB;IAEnB,MAAMC,QAAmC;QAAEC,SAAS,EAAE;QAAEC,MAAM,EAAE;IAAC;IAEjEX,SAASY,OAAO,CAACJ,UAAUK,OAAO,CAACC,CAAAA;QACjC,IAAI,eAACb,eAAea,QAAQ;YAC1BL,MAAME,IAAI,CAACI,IAAI,CAACD;YAChB;QACF;QAEA,OAAQA,MAAME,IAAI;YAChB,KAAKd;gBACHO,MAAMC,OAAO,CAACK,IAAI,CAACD,MAAMG,KAAK;gBAC9B;YACF,KAAKb;gBACHK,MAAMS,MAAM,GAAGJ,MAAMG,KAAK;gBAC1B;YACF,KAAKZ;gBACHI,MAAMU,GAAG,GAAGL,MAAMG,KAAK;gBACvB;YACF,KAAKX;gBACHG,MAAMW,OAAO,GAAG,AAACN,MAAMG,KAAK,CAA6BT,QAAQ;gBACjE;YACF;gBACEC,MAAME,IAAI,CAACI,IAAI,CAACD;QACpB;IACF;IAEA,OAAOL;AACT"}

package/dist/ui/organisms/entity-table/entity-table.d.ts

@@ -0,0 +1,4 @@
+import { type Entity } from '@entifix/core';
+import type { EntityTableProps } from './entity-table.types.js';
+export declare function EntityTable<TEntity extends Entity>({ entityConstructor, isLoading, skeleton, error, items, totalItems, currentPage, pageSize, onPageChange, onPageSizeChange, hrefFor, newHref, onSelect, preferencesKey, showControls, pivotBreakpoint, filtering, sorting, onFilteringChange, onSortingChange, selection, onSelectionChange, metadata, isMetadataLoading, onBulkUseCase, onUseCase, bulkOutcomes, onBulkDismiss, onBulkRetry, isBulkRunning, children, }: EntityTableProps<TEntity>): import("react").JSX.Element;
+//# sourceMappingURL=entity-table.d.ts.map

package/dist/ui/organisms/entity-table/entity-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-table.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/entity-table/entity-table.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,MAAM,EAUZ,MAAM,eAAe,CAAC;AA8BvB,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAwDjC,wBAAgB,WAAW,CAAC,OAAO,SAAS,MAAM,EAAE,EAClD,iBAAiB,EACjB,SAAS,EACT,QAAe,EACf,KAAK,EACL,KAAK,EACL,UAAU,EACV,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,OAAO,EACP,OAAO,EACP,QAAQ,EACR,cAAc,EACd,YAAmB,EACnB,eAAsB,EACtB,SAAS,EACT,OAAO,EACP,iBAAiB,EACjB,eAAe,EACf,SAAS,EACT,iBAAiB,EACjB,QAAQ,EACR,iBAAyB,EACzB,aAAa,EACb,SAAS,EACT,YAAY,EACZ,aAAa,EACb,WAAW,EACX,aAAqB,EACrB,QAAQ,GACT,EAAE,gBAAgB,CAAC,OAAO,CAAC,+BAopB3B"}