@chelone/vue 0.6.0 → 0.9.0

package/dist/inspector.d.ts

@@ -0,0 +1,6 @@
+export { type ConfigurableProps, default as Configurable, } from "./components/inspector/configurable.vue.js";
+export { type ConfigurableInputsProps, default as ConfigurableInputs, } from "./components/inspector/configurable-inputs.vue.js";
+export { default as Inspector, type InspectorProps, } from "./components/inspector/inspector.vue.js";
+export { default as InspectorButton, type InspectorButtonProps, } from "./components/inspector/inspector-button.vue.js";
+export { useInspector } from "./components/inspector/inspector-context.js";
+export { default as SortableFieldsSelector, type SortableFieldsSelectorProps, } from "./components/inspector/sortable-fields-selector.vue.js";

package/dist/inspector.js

@@ -0,0 +1,7 @@
+import configurable_default from "./components/inspector/configurable.js";
+import configurable_inputs_default from "./components/inspector/configurable-inputs.js";
+import inspector_default from "./components/inspector/inspector.js";
+import inspector_button_default from "./components/inspector/inspector-button.js";
+import { useInspector } from "./components/inspector/inspector-context.js";
+import sortable_fields_selector_default from "./components/inspector/sortable-fields-selector.js";
+export { configurable_default as Configurable, configurable_inputs_default as ConfigurableInputs, inspector_default as Inspector, inspector_button_default as InspectorButton, sortable_fields_selector_default as SortableFieldsSelector, useInspector };

package/dist/kanban.js

@@ -1,4 +1 @@
-import { default as default2 } from "./components/kanban/kanban-board.vue.js";
-export {
-  default2 as KanbanBoard
-};
+export { default as KanbanBoard } from "./components/kanban/kanban-board.js";

package/dist/label/inflection.d.ts

@@ -1,25 +1 @@
-/**
- * Clean-room subset of the `inflection` rules the resource-label fallback needs
- * — the Vue twin of `@chelone/react`'s `label/inflection.ts`. `humanize` strips
- * a trailing `_id`, underscores → spaces, lowercases, capitalizes the first
- * letter (no camelCase split, ra-core parity). `pluralize` covers the regular
- * English rules + a small irregular set and is idempotent on plurals. Full
- * parity with the `inflection` package is a documented non-goal — the fallback
- * only fires when both a translation key and an explicit label are absent.
- */
-/**
- * ra-core `humanize`: strip a trailing `_id`, underscores → spaces, lowercase,
- * capitalize the first letter. Deliberately does NOT split camelCase.
- */
-export declare function humanize(text: string): string;
-/**
- * ra-core `transform(source, ['underscore','humanize'])`: camelCase-aware
- * humanization for FIELD labels — `firstName` → `First name`, `full_name` →
- * `Full name`, `author name` → `Author name`. Used by `useTranslateLabel` for
- * the humanized fallback when no translation key and no explicit label exist.
- */
-export declare function humanizeField(source: string): string;
-/**
- * ra-core `inflect(word, count)`: singular for `count === 1`, plural otherwise.
- */
-export declare function pluralize(word: string, count?: number): string;
+export { humanize, humanizeField, pluralize } from "@chelone/core";

package/dist/label/inflection.js

@@ -1,51 +1 @@
-function capitalizeFirst(text) {
-  return text.length === 0 ? text : text.charAt(0).toUpperCase() + text.slice(1);
-}
-function humanize(text) {
-  const withoutId = text.replace(/_id$/, "");
-  const spaced = withoutId.replace(/_+/g, " ").trim().toLowerCase();
-  return capitalizeFirst(spaced);
-}
-function underscore(text) {
-  return text.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
-}
-function humanizeField(source) {
-  return humanize(underscore(source));
-}
-const IRREGULARS = [
-  ["person", "people"],
-  ["child", "children"],
-  ["man", "men"],
-  ["woman", "women"],
-  ["mouse", "mice"],
-  ["foot", "feet"],
-  ["tooth", "teeth"],
-  ["goose", "geese"]
-];
-function toSingular(word) {
-  for (const [singular, plural] of IRREGULARS) {
-    if (word === plural) return singular;
-    if (word === singular) return singular;
-  }
-  if (/ies$/.test(word)) return `${word.slice(0, -3)}y`;
-  if (/(ss|x|z|ch|sh)es$/.test(word)) return word.slice(0, -2);
-  if (/s$/.test(word) && !/ss$/.test(word)) return word.slice(0, -1);
-  return word;
-}
-function toPlural(word) {
-  for (const [singular2, plural] of IRREGULARS) {
-    if (word === singular2 || word === plural) return plural;
-  }
-  const singular = toSingular(word);
-  if (/[^aeiou]y$/.test(singular)) return `${singular.slice(0, -1)}ies`;
-  if (/(s|x|z|ch|sh)$/.test(singular)) return `${singular}es`;
-  return `${singular}s`;
-}
-function pluralize(word, count = 2) {
-  return count === 1 ? toSingular(word) : toPlural(word);
-}
-export {
-  humanize,
-  humanizeField,
-  pluralize
-};
+export { humanize, humanizeField, pluralize } from "@chelone/core";

package/dist/label/use-get-record-representation.d.ts

@@ -15,6 +15,7 @@
  * with no registry, only the default chain applies. The string-path read is
  * core's `getAtPath`, the same reader `useFieldValue` uses.
  */
+import { type ResourceRecord } from "@chelone/core";
 /** The resolver `useGetRecordRepresentation` returns. */
-export type GetRecordRepresentation = (record: unknown) => string;
+export type GetRecordRepresentation = (record: ResourceRecord | null | undefined) => string;
 export declare function useGetRecordRepresentation(resource?: string): GetRecordRepresentation;

package/dist/label/use-get-record-representation.js

@@ -1,32 +1,54 @@
-import { getAtPath } from "@chelone/core";
-import { inject } from "vue";
 import { ResourceRegistryKey } from "../admin/resource-registry.js";
 import { useResourceContext } from "../resource-context.js";
+import { inject } from "vue";
+import { getAtPath } from "@chelone/core";
+// src/label/use-get-record-representation.ts
+/**
+* `useGetRecordRepresentation(resource?)` — resolve a record to its display
+* representation. The Vue twin of `@chelone/react`'s
+* `label/use-get-record-representation.tsx` (ra-core parity, clean-room).
+*
+* Reads the resource's `recordRepresentation` from the ambient registry and
+* applies:
+* - a function → call it with the record;
+* - a string → the value at that (deep) source path off the record;
+* - otherwise the default chain `name → title → label → reference → #${id}`.
+* A nullish record → `""`.
+*
+* The resource comes from the argument or the ambient `<Resource>` name. The
+* registry is optional (a form/field used without `<Admin>` in a unit test):
+* with no registry, only the default chain applies. The string-path read is
+* core's `getAtPath`, the same reader `useFieldValue` uses.
+*/
 function isPresent(value) {
-  return value != null && value !== "";
+	return value != null && value !== "";
+}
+/**
+* Whether the representation is a function to call with the record. A Vue
+* `Component` can also be a function (a functional component, a constructor),
+* and the types cannot tell the two apart, so any function is called as one.
+*/
+function isRepresentationFunction(value) {
+	return typeof value === "function";
 }
 function useGetRecordRepresentation(resource) {
-  const name = useResourceContext({ resource });
-  const registry = inject(ResourceRegistryKey, null);
-  const recordRepresentation = name ? registry?.definitions[name]?.recordRepresentation : void 0;
-  return (record) => {
-    if (record == null) return "";
-    if (typeof recordRepresentation === "function") {
-      return String(
-        recordRepresentation(record) ?? ""
-      );
-    }
-    if (typeof recordRepresentation === "string") {
-      return String(getAtPath(record, recordRepresentation) ?? "");
-    }
-    const chain = record;
-    if (isPresent(chain.name)) return String(chain.name);
-    if (isPresent(chain.title)) return String(chain.title);
-    if (isPresent(chain.label)) return String(chain.label);
-    if (isPresent(chain.reference)) return String(chain.reference);
-    return `#${String(chain.id)}`;
-  };
+	const name = useResourceContext({ resource });
+	const registry = inject(ResourceRegistryKey, null);
+	const recordRepresentation = name ? registry?.definitions[name]?.recordRepresentation : void 0;
+	return (record) => {
+		if (record == null) return "";
+		if (recordRepresentation !== void 0 && isRepresentationFunction(recordRepresentation)) return String(recordRepresentation(record) ?? "");
+		if (typeof recordRepresentation === "string") return String(getAtPath(record, recordRepresentation) ?? "");
+		for (const key of [
+			"name",
+			"title",
+			"label",
+			"reference"
+		]) {
+			const value = getAtPath(record, key);
+			if (isPresent(value)) return String(value);
+		}
+		return `#${String(getAtPath(record, "id"))}`;
+	};
 }
-export {
-  useGetRecordRepresentation
-};
+export { useGetRecordRepresentation };

package/dist/label/use-get-resource-label.js

@@ -1,14 +1,27 @@
 import { useTranslate } from "../i18n/use-translate.js";
 import { humanize, pluralize } from "./inflection.js";
+// src/label/use-get-resource-label.ts
+/**
+* `useGetResourceLabel()` — returns `(resource, count?) => string`, the Vue twin
+* of `@chelone/react`'s `label/use-get-resource-label.ts` (ra-core parity).
+* Translates `resources.${resource}.name` with pluralization, falling back to a
+* humanized, count-inflected default when the key is missing (Chelone
+* `translate` echoes the key on a miss).
+*
+* Vue divergence from the React twin: the adapter's `ResourceDefinition` carries
+* no `options.label` bag (a later wave), so the fallback is purely the humanized
+* plural of the resource name — no per-resource label override yet.
+*/
 function useGetResourceLabel() {
-  const translate = useTranslate();
-  return (resource, count = 2) => {
-    const humanizedDefault = humanize(pluralize(resource, count));
-    const key = `resources.${resource}.name`;
-    const translated = translate(key, { count, smart_count: count });
-    return translated === key ? humanizedDefault : translated;
-  };
+	const translate = useTranslate();
+	return (resource, count = 2) => {
+		const humanizedDefault = humanize(pluralize(resource, count));
+		const key = `resources.${resource}.name`;
+		const translated = translate(key, {
+			count,
+			smart_count: count
+		});
+		return translated === key ? humanizedDefault : translated;
+	};
 }
-export {
-  useGetResourceLabel
-};
+export { useGetResourceLabel };

package/dist/label/use-translate-label.js

@@ -2,47 +2,72 @@ import { useSourceScope } from "../form/form-context.js";
 import { useTranslate } from "../i18n/use-translate.js";
 import { useResourceContext } from "../resource-context.js";
 import { humanizeField } from "./inflection.js";
+// src/label/use-translate-label.ts
+/**
+* `useTranslateLabel()` — the Vue twin of `@chelone/react`'s
+* `label/use-translate-label.tsx`. Returns a resolver
+* `({ source, label?, resource? }) => string | null` that computes a field's
+* displayable label text:
+* - `label === false` or `label === ""` → `null` (render no label);
+* - a non-empty string `label` → translate it (echoing itself on a miss);
+* - otherwise translate `resources.${resource}.fields.${source}`, falling back
+*   to the humanized field name when the key is missing.
+*
+* The default label KEY follows ra-core's `getFieldLabelTranslationArgs`:
+* digits are stripped from the source (`tags.0.url` → `tags.url`), and the
+* humanized DEFAULT is derived from the source SUFFIX after the last index
+* (`tags.0.url` → `url` → `Url`). The resource comes from the `resource`
+* option, the ambient source scope's `getLabel(source)`, or the ambient
+* `ResourceContext`.
+*
+* Idiom translation from the React twin: React returns a `ReactNode` (a label
+* may be a node); Vue keeps the resolver STRING-typed (`string | null`) and
+* handles a custom-node label at the `<FieldLabelText>` component seam via a
+* slot, so this composable stays presentation-free and fully typed. Core's
+* `translate` echoes the key on a miss (no polyglot `_`), so the
+* humanized-field fallback is applied here when `translate(key) === key`.
+*/
+/**
+* Split a source into its digit-free path and the suffix after the last index.
+* `pictures.0.url` → `{ sourceWithoutDigits: "pictures.url", sourceSuffix:
+* "url" }`; `pictures` → `{ "pictures", "pictures" }`.
+*/
 function getSourceParts(source) {
-  const sourceWithoutDigits = source.replace(/\.\d+\./g, ".");
-  const parts = source.split(".");
-  let lastIndex;
-  parts.forEach((part, index) => {
-    if (part.length > 0 && /^\d+$/.test(part)) lastIndex = index;
-  });
-  const sourceSuffix = lastIndex != null ? parts.slice(lastIndex + 1).join(".") : source;
-  return { sourceWithoutDigits, sourceSuffix };
+	const sourceWithoutDigits = source.replace(/\.\d+\./g, ".");
+	const parts = source.split(".");
+	let lastIndex;
+	parts.forEach((part, index) => {
+		if (part.length > 0 && /^\d+$/.test(part)) lastIndex = index;
+	});
+	return {
+		sourceWithoutDigits,
+		sourceSuffix: lastIndex != null ? parts.slice(lastIndex + 1).join(".") : source
+	};
 }
-const fieldLabelKey = (resource, source) => `resources.${resource}.fields.${source}`;
+var fieldLabelKey = (resource, source) => `resources.${resource}.fields.${source}`;
+/**
+* Resolve field labels against the ambient i18n + resource + source scope. The
+* returned resolver reads those ambient values at call time, so it stays
+* reactive to a locale/resource change (the caller wraps it in a `computed`).
+*/
 function useTranslateLabel() {
-  const translate = useTranslate();
-  const resourceFromContext = useResourceContext();
-  const sourceScope = useSourceScope();
-  return ({
-    source,
-    label,
-    resource
-  }) => {
-    if (label === false || label === "") return null;
-    if (typeof label === "string") {
-      return translate(label, { _: label });
-    }
-    if (source == null) return "";
-    const { sourceWithoutDigits, sourceSuffix } = getSourceParts(source);
-    const humanizedDefault = humanizeField(sourceSuffix.replace(/\./g, " "));
-    let key;
-    if (resource) {
-      key = fieldLabelKey(resource, sourceWithoutDigits);
-    } else {
-      const contextLabel = sourceScope.getLabel(source);
-      key = contextLabel && contextLabel !== source ? contextLabel : fieldLabelKey(
-        resourceFromContext ?? "undefined",
-        sourceWithoutDigits
-      );
-    }
-    const translated = translate(key);
-    return translated === key ? humanizedDefault : translated;
-  };
+	const translate = useTranslate();
+	const resourceFromContext = useResourceContext();
+	const sourceScope = useSourceScope();
+	return ({ source, label, resource }) => {
+		if (label === false || label === "") return null;
+		if (typeof label === "string") return translate(label, { _: label });
+		if (source == null) return "";
+		const { sourceWithoutDigits, sourceSuffix } = getSourceParts(source);
+		const humanizedDefault = humanizeField(sourceSuffix.replace(/\./g, " "));
+		let key;
+		if (resource) key = fieldLabelKey(resource, sourceWithoutDigits);
+		else {
+			const contextLabel = sourceScope.getLabel(source);
+			key = contextLabel && contextLabel !== source ? contextLabel : fieldLabelKey(resourceFromContext ?? "undefined", sourceWithoutDigits);
+		}
+		const translated = translate(key);
+		return translated === key ? humanizedDefault : translated;
+	};
 }
-export {
-  useTranslateLabel
-};
+export { useTranslateLabel };

package/dist/lib/are-ids-equal.js

@@ -1,8 +1,13 @@
+// src/lib/are-ids-equal.ts
+/**
+* `areIdsEqual` — compares two record ids for equality, coercing to strings so a
+* numeric id sourced from a data provider matches a string id held in form
+* state. The Vue twin of `@chelone/react`'s `lib/are-ids-equal.ts` (the
+* autocomplete inputs' default option-vs-value equality check).
+*/
 function areIdsEqual(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  return String(a) === String(b);
+	if (a === b) return true;
+	if (a == null || b == null) return false;
+	return String(a) === String(b);
 }
-export {
-  areIdsEqual
-};
+export { areIdsEqual };

package/dist/lib/shallow-equal.d.ts

@@ -1,15 +1 @@
-/**
- * `shallowEqual(a, b)` — shallow equality with `Object.is` semantics at the top
- * level, the Vue twin of `@chelone/react`'s `util/shallow-equal.ts` (parity with
- * ra-core's `shallowEqual`). Used by `<FileInput>` to identify the file to drop
- * from a `multiple` value array (file records are compared by their own
- * enumerable keys, not by reference, so a re-`format`ted copy still matches).
- *
- * - reference-equal inputs (and `Object.is`-equal primitives) are equal;
- * - `+0` / `-0` are NOT equal, `NaN` / `NaN` ARE equal (Object.is);
- * - two objects/arrays are equal iff they have the same own enumerable keys and
- *   each value pair is `Object.is`-equal — nested values are compared by
- *   reference only (shallow);
- * - a non-object (or `null`) that is not reference-equal is unequal.
- */
-export declare function shallowEqual(a: unknown, b: unknown): boolean;
+export { shallowEqual } from "@chelone/core";

package/dist/lib/shallow-equal.js

@@ -1,27 +1 @@
-function is(x, y) {
-  if (x === y) {
-    return x !== 0 || y !== 0 || 1 / x === 1 / y;
-  }
-  return Number.isNaN(x) && Number.isNaN(y);
-}
-function shallowEqual(a, b) {
-  if (is(a, b)) return true;
-  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
-    return false;
-  }
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) return false;
-  for (const key of keysA) {
-    if (!Object.hasOwn(b, key) || !is(
-      a[key],
-      b[key]
-    )) {
-      return false;
-    }
-  }
-  return true;
-}
-export {
-  shallowEqual
-};
+export { shallowEqual } from "@chelone/core";

package/dist/lib/utils.js

@@ -1,16 +1,14 @@
+// src/lib/utils.ts
+/** Join truthy class values into a single space-separated string. */
 function cn(...values) {
-  const out = [];
-  for (const value of values) {
-    if (!value) continue;
-    if (Array.isArray(value)) {
-      const nested = cn(...value);
-      if (nested) out.push(nested);
-    } else {
-      out.push(value);
-    }
-  }
-  return out.join(" ");
+	const out = [];
+	for (const value of values) {
+		if (!value) continue;
+		if (Array.isArray(value)) {
+			const nested = cn(...value);
+			if (nested) out.push(nested);
+		} else out.push(value);
+	}
+	return out.join(" ");
 }
-export {
-  cn
-};
+export { cn };

package/dist/lib/vnode-children.d.ts

@@ -0,0 +1,18 @@
+import { type VNode } from "vue";
+/**
+ * The vnodes among a vnode's children, flattening nested arrays. Strings
+ * (a text child, or a raw string inside an array) are skipped.
+ */
+export declare function childVNodes(node: VNode): VNode[];
+/**
+ * `nodes` with the fragments `v-for` makes opened up and the comments `v-if`
+ * leaves dropped, so each remaining node is one the author wrote.
+ */
+export declare function flattenVNodes(nodes: readonly VNode[]): VNode[];
+/**
+ * The nodes at `shown`, in that order, each keyed by its column id. A node
+ * keeps its component instance when its position changes: columns and inputs
+ * read their props once, so a reused instance would show another one's data. A
+ * key the author set is kept, and a repeated id gets a count after it.
+ */
+export declare function keyByColumnId(nodes: readonly VNode[], ids: readonly (string | undefined)[], shown: readonly number[]): VNode[];

package/dist/lib/vnode-children.js

@@ -0,0 +1,46 @@
+import { Comment, Fragment, cloneVNode, isVNode } from "vue";
+// src/lib/vnode-children.ts
+/**
+* The vnodes among a vnode's children, flattening nested arrays. Strings
+* (a text child, or a raw string inside an array) are skipped.
+*/
+function childVNodes(node) {
+	const out = [];
+	const walk = (value) => {
+		if (Array.isArray(value)) for (const item of value) walk(item);
+		else if (isVNode(value)) out.push(value);
+	};
+	walk(node.children);
+	return out;
+}
+/**
+* `nodes` with the fragments `v-for` makes opened up and the comments `v-if`
+* leaves dropped, so each remaining node is one the author wrote.
+*/
+function flattenVNodes(nodes) {
+	return nodes.flatMap((node) => {
+		if (node.type === Comment) return [];
+		if (node.type === Fragment) return flattenVNodes(childVNodes(node));
+		return [node];
+	});
+}
+/**
+* The nodes at `shown`, in that order, each keyed by its column id. A node
+* keeps its component instance when its position changes: columns and inputs
+* read their props once, so a reused instance would show another one's data. A
+* key the author set is kept, and a repeated id gets a count after it.
+*/
+function keyByColumnId(nodes, ids, shown) {
+	const taken = /* @__PURE__ */ new Map();
+	return shown.flatMap((index) => {
+		const node = nodes[index];
+		if (node === void 0) return [];
+		if (node.key != null) return [node];
+		const id = ids[index];
+		const base = id === void 0 ? `index:${index}` : `id:${id}`;
+		const count = taken.get(base) ?? 0;
+		taken.set(base, count + 1);
+		return [cloneVNode(node, { key: count === 0 ? base : `${base}:${count}` })];
+	});
+}
+export { childVNodes, flattenVNodes, keyByColumnId };

package/dist/list/infinite-list-context.js

@@ -1,17 +1,12 @@
 import { useListContext } from "./list-context.js";
+// src/list/infinite-list-context.ts
 function isInfiniteList(list) {
-  const candidate = list;
-  return typeof candidate.fetchNextPage === "function" && typeof candidate.fetchPreviousPage === "function";
+	const candidate = list;
+	return typeof candidate.fetchNextPage === "function" && typeof candidate.fetchPreviousPage === "function";
 }
 function useInfiniteListContext() {
-  const list = useListContext();
-  if (!isInfiniteList(list)) {
-    throw new Error(
-      "useInfiniteListContext: the ambient list is not an infinite list"
-    );
-  }
-  return list;
+	const list = useListContext();
+	if (!isInfiniteList(list)) throw new Error("useInfiniteListContext: the ambient list is not an infinite list");
+	return list;
 }
-export {
-  useInfiniteListContext
-};
+export { useInfiniteListContext };

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

@@ -11,14 +11,17 @@
  * read it directly with no ref juggling. `useListContext` throws without a
  * provider (parity with the React twin).
  */
-import type { RecordOf, ResourceMap } from "@chelone/core";
+import type { LooseRecord } from "@chelone/core";
 import { type InjectionKey } from "vue";
 import type { UseListControllerReturn } from "../controllers/use-list-controller.js";
 /** The ambient list surface — the reactive `useListController` result. */
-export type ListContextValue<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string> = UseListControllerReturn<RecordOf<TResources, TName>>;
+export type ListContextValue<TRecord = LooseRecord> = UseListControllerReturn<TRecord>;
 /** The provide/inject key for the ambient list surface. */
 export declare const ListContextKey: InjectionKey<ListContextValue>;
 /** Provide the ambient list surface (called by `<List>` in `setup`). */
 export declare function provideListContext(value: ListContextValue): void;
-/** The ambient list surface; throws without a `<List>`/provider above. */
-export declare function useListContext<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(): ListContextValue<TResources, TName>;
+/**
+ * The ambient list surface; throws without a `<List>`/provider above.
+ * `TRecord` is unconstrained: a `RecordOf` is not always a `ResourceRecord`.
+ */
+export declare function useListContext<TRecord = LooseRecord>(): ListContextValue<TRecord>;

package/dist/list/list-context.js

@@ -1,19 +1,18 @@
-import { provide, inject } from "vue";
-const ListContextKey = /* @__PURE__ */ Symbol(
-  "chelone-list-context"
-);
+import { inject, provide } from "vue";
+// src/list/list-context.ts
+/** The provide/inject key for the ambient list surface. */
+var ListContextKey = Symbol("chelone-list-context");
+/** Provide the ambient list surface (called by `<List>` in `setup`). */
 function provideListContext(value) {
-  provide(ListContextKey, value);
+	provide(ListContextKey, value);
 }
+/**
+* The ambient list surface; throws without a `<List>`/provider above.
+* `TRecord` is unconstrained: a `RecordOf` is not always a `ResourceRecord`.
+*/
 function useListContext() {
-  const ctx = inject(ListContextKey, null);
-  if (!ctx) {
-    throw new Error("useListContext: no <List> found above this component.");
-  }
-  return ctx;
+	const ctx = inject(ListContextKey, null);
+	if (!ctx) throw new Error("useListContext: no <List> found above this component.");
+	return ctx;
 }
-export {
-  ListContextKey,
-  provideListContext,
-  useListContext
-};
+export { ListContextKey, provideListContext, useListContext };

package/dist/list/use-data-table-columns.d.ts

@@ -12,6 +12,8 @@ export interface UseDataTableColumnsResult {
     /** The stored hidden ids, or `defaultHiddenColumns` until a choice is stored. */
     hidden: Readonly<Ref<readonly string[]>>;
     order: Readonly<Ref<readonly string[]>>;
+    /** Put the column `id` at `index` of the order, which is clamped to its ends. */
+    moveTo: (id: string, index: number) => void;
     toggle: (id: string) => void;
     move: (id: string, direction: -1 | 1) => void;
     /** Forget the stored choice: the defaults apply again. */