@chelone/core 0.6.0 → 0.7.0

package/dist/controller/client-list-controller.js

@@ -1,266 +1,263 @@
+import { isFilterBranch } from "../data/filter-branch.js";
+import { removeEmpty } from "../data/remove-empty.js";
 import { getAtPath } from "../resource/get-at-path.js";
 import { createMicroStore } from "../store/micro-store.js";
-import { removeFilterPath, listParamsFromPatch } from "./list-controller.js";
-const DEFAULT_PER_PAGE = 1e3;
-const DEFAULT_SORT = [];
+import { listParamsFromPatch, removeFilterPath } from "./list-controller.js";
+// src/controller/client-list-controller.ts
+var DEFAULT_PER_PAGE = 1e3;
+var DEFAULT_SORT = [];
 function normalizeSort(sort) {
-  if (!sort) return DEFAULT_SORT.map((entry) => ({ ...entry }));
-  const entries = Array.isArray(sort) ? sort : [sort];
-  return entries.map((entry) => ({ ...entry }));
-}
-function removeEmpty(filter) {
-  const result = {};
-  for (const [key, value] of Object.entries(filter)) {
-    if (value === "" || value === null || value === void 0) continue;
-    result[key] = value;
-  }
-  return result;
+	if (!sort) return DEFAULT_SORT.map((entry) => ({ ...entry }));
+	return (Array.isArray(sort) ? sort : [sort]).map((entry) => ({ ...entry }));
 }
+/**
+* Flatten a nested filter object into dotted keys (`{nested:{level:5}}` →
+* `{'nested.level':5}`), matching ra-core's `flattenObject`. Arrays and
+* non-plain values are treated as LEAVES (never recursed).
+*/
 function flattenFilter(filter, prefix = "") {
-  const result = {};
-  for (const [key, value] of Object.entries(filter)) {
-    const path = prefix ? `${prefix}.${key}` : key;
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
-      Object.assign(result, flattenFilter(value, path));
-    } else {
-      result[path] = value;
-    }
-  }
-  return result;
+	const result = {};
+	for (const [key, value] of Object.entries(filter)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (isFilterBranch(value)) Object.assign(result, flattenFilter(value, path));
+		else result[path] = value;
+	}
+	return result;
 }
+/** Does one record satisfy every flattened filter entry (ra-core semantics)? */
 function matchesFilter(record, flatFilter) {
-  return Object.entries(flatFilter).every(([filterName, filterValue]) => {
-    const recordValue = getAtPath(record, filterName);
-    if (Array.isArray(recordValue)) {
-      return Array.isArray(filterValue) ? recordValue.some((item) => filterValue.includes(item)) : recordValue.includes(filterValue);
-    }
-    if (Array.isArray(filterValue)) {
-      return filterValue.includes(recordValue);
-    }
-    if (filterName === "q") {
-      const needle = String(filterValue).toLowerCase();
-      return Object.values(record).some(
-        (value) => typeof value === "string" && value.toLowerCase().includes(needle)
-      );
-    }
-    return filterValue == recordValue;
-  });
+	return Object.entries(flatFilter).every(([filterName, filterValue]) => {
+		const recordValue = getAtPath(record, filterName);
+		if (Array.isArray(recordValue)) return Array.isArray(filterValue) ? recordValue.some((item) => filterValue.includes(item)) : recordValue.includes(filterValue);
+		if (Array.isArray(filterValue)) return filterValue.includes(recordValue);
+		if (filterName === "q") {
+			const needle = String(filterValue).toLowerCase();
+			return Object.values(record).some((value) => typeof value === "string" && value.toLowerCase().includes(needle));
+		}
+		return filterValue == recordValue;
+	});
 }
 function applyFilterAndSort(records, filter, sort, filterCallback) {
-  let result = records;
-  const flatFilter = flattenFilter(filter);
-  if (Object.keys(flatFilter).length > 0) {
-    result = result.filter((record) => matchesFilter(record, flatFilter));
-  }
-  result = result.filter(filterCallback);
-  const keys = sort.filter((entry) => entry.field);
-  if (keys.length > 0) {
-    result = [...result].sort((a, b) => {
-      for (const { field, order } of keys) {
-        const asc = order === "ASC";
-        const av = getAtPath(a, field);
-        const bv = getAtPath(b, field);
-        if (av === bv || av == null && bv == null) continue;
-        if (av == null) return asc ? -1 : 1;
-        if (bv == null) return asc ? 1 : -1;
-        if (av > bv) return asc ? 1 : -1;
-        if (av < bv) return asc ? -1 : 1;
-      }
-      return 0;
-    });
-  }
-  return result;
+	let result = records;
+	const flatFilter = flattenFilter(filter);
+	if (Object.keys(flatFilter).length > 0) result = result.filter((record) => matchesFilter(record, flatFilter));
+	result = result.filter(filterCallback);
+	const keys = sort.filter((entry) => entry.field);
+	if (keys.length > 0) result = [...result].sort((a, b) => {
+		for (const { field, order } of keys) {
+			const asc = order === "ASC";
+			const av = getAtPath(a, field);
+			const bv = getAtPath(b, field);
+			if (av === bv || av == null && bv == null) continue;
+			if (av == null) return asc ? -1 : 1;
+			if (bv == null) return asc ? 1 : -1;
+			if (av > bv) return asc ? 1 : -1;
+			if (av < bv) return asc ? -1 : 1;
+		}
+		return 0;
+	});
+	return result;
 }
+/**
+* Vanilla client-side list controller. Pure state + closures over a
+* {@link createMicroStore}; NO QueryObserver, NO subscriptions to acquire —
+* every derived value is recomputed synchronously from the current params +
+* source data. Selection is local (never KV-synced — an in-memory list has no
+* cross-instance identity).
+*
+* Shape parity: it satisfies {@link ListController} so the React `useList` hook
+* returns the SAME `UseListControllerResult` a `<ListContextProvider>` /
+* `useListContext` consumer already reads.
+*/
 function createClientListController(options) {
-  const filterCallback = options.filterCallback ?? ((record) => Boolean(record));
-  let source = options.data;
-  const store = createMicroStore({
-    page: options.page ?? 1,
-    perPage: options.perPage ?? DEFAULT_PER_PAGE,
-    sort: normalizeSort(options.sort),
-    filter: removeEmpty(options.filter ?? {}),
-    displayedFilters: {},
-    selectedIds: [],
-    data: void 0,
-    total: void 0,
-    pageInfo: void 0,
-    isPending: options.isPending ?? false,
-    isFetching: options.isFetching ?? false,
-    error: options.error ?? null,
-    hasNextPage: void 0,
-    hasPreviousPage: void 0
-  });
-  let destroyed = false;
-  store.onDestroy(() => {
-    destroyed = true;
-  });
-  const recompute = () => {
-    const s = store.getSnapshot();
-    if (s.isPending || source === void 0) {
-      store.setState({
-        data: void 0,
-        total: void 0,
-        hasNextPage: false,
-        hasPreviousPage: false
-      });
-      return;
-    }
-    const filteredAndSorted = applyFilterAndSort(
-      source,
-      s.filter,
-      s.sort,
-      filterCallback
-    );
-    const total = filteredAndSorted.length;
-    const lastPage = Math.max(Math.ceil(total / s.perPage), 1);
-    const page = Math.min(Math.max(s.page, 1), lastPage);
-    const start = (page - 1) * s.perPage;
-    const paginated = filteredAndSorted.slice(start, start + s.perPage);
-    store.setState({
-      page,
-      data: paginated,
-      total,
-      hasNextPage: page * s.perPage < total,
-      hasPreviousPage: page > 1
-    });
-  };
-  recompute();
-  const setPage = (page) => {
-    if (destroyed) return;
-    store.setState({ page });
-    recompute();
-  };
-  const setPerPage = (perPage) => {
-    if (destroyed) return;
-    store.setState({ perPage, page: 1 });
-    recompute();
-  };
-  const setSort = (input) => {
-    if (destroyed) return;
-    const current = store.getSnapshot().sort;
-    const single = current.length === 1 ? current[0] : void 0;
-    let next;
-    if (Array.isArray(input)) {
-      next = input.map((entry) => ({ ...entry }));
-    } else if (single && single.field === input.field) {
-      next = [
-        { field: input.field, order: single.order === "ASC" ? "DESC" : "ASC" }
-      ];
-    } else {
-      next = [{ field: input.field, order: input.order ?? "ASC" }];
-    }
-    store.setState({ sort: next, page: 1 });
-    recompute();
-  };
-  const setFilters = (filter, displayedFilters) => {
-    if (destroyed) return;
-    store.setState({
-      filter: removeEmpty(filter),
-      displayedFilters: displayedFilters === void 0 ? store.getSnapshot().displayedFilters : { ...displayedFilters },
-      page: 1
-    });
-    recompute();
-  };
-  const setParams = (patch) => {
-    if (destroyed) return;
-    const next = listParamsFromPatch(patch);
-    if (Object.keys(next).length === 0) return;
-    store.setState(next);
-    recompute();
-  };
-  const showFilter = (name, defaultValue) => {
-    if (destroyed) return;
-    const s = store.getSnapshot();
-    store.setState({
-      filter: defaultValue === void 0 ? s.filter : removeEmpty({ ...s.filter, [name]: defaultValue }),
-      displayedFilters: { ...s.displayedFilters, [name]: true }
-    });
-    recompute();
-  };
-  const hideFilter = (name) => {
-    if (destroyed) return;
-    const s = store.getSnapshot();
-    const filter = removeFilterPath(s.filter, name);
-    const { [name]: _shown, ...displayedFilters } = s.displayedFilters;
-    store.setState({ filter, displayedFilters, page: 1 });
-    recompute();
-  };
-  const select = (ids) => {
-    if (destroyed) return;
-    store.setState({ selectedIds: [...ids] });
-  };
-  const toggleItem = (id) => {
-    if (destroyed) return;
-    const current = store.getSnapshot().selectedIds;
-    store.setState({
-      selectedIds: current.includes(id) ? current.filter((existing) => existing !== id) : [...current, id]
-    });
-  };
-  const unselectAll = () => {
-    if (destroyed) return;
-    store.setState({ selectedIds: [] });
-  };
-  const selectAll = async (opts) => {
-    if (destroyed) return;
-    if (source === void 0) return;
-    const s = store.getSnapshot();
-    const filteredAndSorted = applyFilterAndSort(
-      source,
-      s.filter,
-      s.sort,
-      filterCallback
-    );
-    const limited = opts?.limit != null ? filteredAndSorted.slice(0, opts.limit) : filteredAndSorted;
-    store.setState({ selectedIds: limited.map((record) => record.id) });
-  };
-  const refetch = () => {
-  };
-  const setData = (data) => {
-    if (destroyed) return;
-    source = data;
-    recompute();
-  };
-  const setSourceFilter = (filter) => {
-    if (destroyed) return;
-    store.setState({ filter: removeEmpty(filter), page: 1 });
-    recompute();
-  };
-  const setLoadingState = (patch) => {
-    if (destroyed) return;
-    const s = store.getSnapshot();
-    const next = {};
-    if (patch.isPending !== void 0 && patch.isPending !== s.isPending) {
-      next.isPending = patch.isPending;
-    }
-    if (patch.isFetching !== void 0 && patch.isFetching !== s.isFetching) {
-      next.isFetching = patch.isFetching;
-    }
-    if (patch.error !== void 0 && patch.error !== s.error) {
-      next.error = patch.error;
-    }
-    if (Object.keys(next).length === 0) return;
-    store.setState(next);
-    if (next.isPending !== void 0) recompute();
-  };
-  return {
-    ...store,
-    setPage,
-    setPerPage,
-    setSort,
-    setFilters,
-    setParams,
-    showFilter,
-    hideFilter,
-    select,
-    toggleItem,
-    unselectAll,
-    selectAll,
-    refetch,
-    setData,
-    setSourceFilter,
-    setLoadingState
-  };
+	const filterCallback = options.filterCallback ?? ((record) => Boolean(record));
+	let source = options.data;
+	const store = createMicroStore({
+		page: options.page ?? 1,
+		perPage: options.perPage ?? DEFAULT_PER_PAGE,
+		sort: normalizeSort(options.sort),
+		filter: removeEmpty(options.filter ?? {}),
+		displayedFilters: {},
+		selectedIds: [],
+		data: void 0,
+		total: void 0,
+		pageInfo: void 0,
+		isPending: options.isPending ?? false,
+		isFetching: options.isFetching ?? false,
+		error: options.error ?? null,
+		hasNextPage: void 0,
+		hasPreviousPage: void 0
+	});
+	let destroyed = false;
+	store.onDestroy(() => {
+		destroyed = true;
+	});
+	/** Recompute the derived slice (data/total/paging flags) from source + params. */
+	const recompute = () => {
+		const s = store.getSnapshot();
+		if (s.isPending || source === void 0) {
+			store.setState({
+				data: void 0,
+				total: void 0,
+				hasNextPage: false,
+				hasPreviousPage: false
+			});
+			return;
+		}
+		const filteredAndSorted = applyFilterAndSort(source, s.filter, s.sort, filterCallback);
+		const total = filteredAndSorted.length;
+		const lastPage = Math.max(Math.ceil(total / s.perPage), 1);
+		const page = Math.min(Math.max(s.page, 1), lastPage);
+		const start = (page - 1) * s.perPage;
+		const paginated = filteredAndSorted.slice(start, start + s.perPage);
+		store.setState({
+			page,
+			data: paginated,
+			total,
+			hasNextPage: page * s.perPage < total,
+			hasPreviousPage: page > 1
+		});
+	};
+	recompute();
+	const setPage = (page) => {
+		if (destroyed) return;
+		store.setState({ page });
+		recompute();
+	};
+	const setPerPage = (perPage) => {
+		if (destroyed) return;
+		store.setState({
+			perPage,
+			page: 1
+		});
+		recompute();
+	};
+	const setSort = (input) => {
+		if (destroyed) return;
+		const current = store.getSnapshot().sort;
+		const single = current.length === 1 ? current[0] : void 0;
+		let next;
+		if (Array.isArray(input)) next = input.map((entry) => ({ ...entry }));
+		else if (single && single.field === input.field) next = [{
+			field: input.field,
+			order: single.order === "ASC" ? "DESC" : "ASC"
+		}];
+		else next = [{
+			field: input.field,
+			order: input.order ?? "ASC"
+		}];
+		store.setState({
+			sort: next,
+			page: 1
+		});
+		recompute();
+	};
+	const setFilters = (filter, displayedFilters) => {
+		if (destroyed) return;
+		store.setState({
+			filter: removeEmpty(filter),
+			displayedFilters: displayedFilters === void 0 ? store.getSnapshot().displayedFilters : { ...displayedFilters },
+			page: 1
+		});
+		recompute();
+	};
+	const setParams = (patch) => {
+		if (destroyed) return;
+		const next = listParamsFromPatch(patch);
+		if (Object.keys(next).length === 0) return;
+		store.setState(next);
+		recompute();
+	};
+	const showFilter = (name, defaultValue) => {
+		if (destroyed) return;
+		const s = store.getSnapshot();
+		store.setState({
+			filter: defaultValue === void 0 ? s.filter : removeEmpty({
+				...s.filter,
+				[name]: defaultValue
+			}),
+			displayedFilters: {
+				...s.displayedFilters,
+				[name]: true
+			}
+		});
+		recompute();
+	};
+	const hideFilter = (name) => {
+		if (destroyed) return;
+		const s = store.getSnapshot();
+		const filter = removeFilterPath(s.filter, name);
+		const { [name]: _shown, ...displayedFilters } = s.displayedFilters;
+		store.setState({
+			filter,
+			displayedFilters,
+			page: 1
+		});
+		recompute();
+	};
+	const select = (ids) => {
+		if (destroyed) return;
+		store.setState({ selectedIds: [...ids] });
+	};
+	const toggleItem = (id) => {
+		if (destroyed) return;
+		const current = store.getSnapshot().selectedIds;
+		store.setState({ selectedIds: current.includes(id) ? current.filter((existing) => existing !== id) : [...current, id] });
+	};
+	const unselectAll = () => {
+		if (destroyed) return;
+		store.setState({ selectedIds: [] });
+	};
+	const selectAll = async (opts) => {
+		if (destroyed) return;
+		if (source === void 0) return;
+		const s = store.getSnapshot();
+		const filteredAndSorted = applyFilterAndSort(source, s.filter, s.sort, filterCallback);
+		const limited = opts?.limit != null ? filteredAndSorted.slice(0, opts.limit) : filteredAndSorted;
+		store.setState({ selectedIds: limited.map((record) => record.id) });
+	};
+	const refetch = () => {};
+	const setData = (data) => {
+		if (destroyed) return;
+		source = data;
+		recompute();
+	};
+	const setSourceFilter = (filter) => {
+		if (destroyed) return;
+		store.setState({
+			filter: removeEmpty(filter),
+			page: 1
+		});
+		recompute();
+	};
+	const setLoadingState = (patch) => {
+		if (destroyed) return;
+		const s = store.getSnapshot();
+		const next = {};
+		if (patch.isPending !== void 0 && patch.isPending !== s.isPending) next.isPending = patch.isPending;
+		if (patch.isFetching !== void 0 && patch.isFetching !== s.isFetching) next.isFetching = patch.isFetching;
+		if (patch.error !== void 0 && patch.error !== s.error) next.error = patch.error;
+		if (Object.keys(next).length === 0) return;
+		store.setState(next);
+		if (next.isPending !== void 0) recompute();
+	};
+	return {
+		...store,
+		setPage,
+		setPerPage,
+		setSort,
+		setFilters,
+		setParams,
+		showFilter,
+		hideFilter,
+		select,
+		toggleItem,
+		unselectAll,
+		selectAll,
+		refetch,
+		setData,
+		setSourceFilter,
+		setLoadingState
+	};
 }
-export {
-  createClientListController
-};
+export { createClientListController };

package/dist/controller/data-table-columns.d.ts

@@ -20,4 +20,6 @@ export declare function arrangeColumns(ids: readonly (string | undefined)[], { h
 }): number[];
 export declare function toggleHiddenColumn(hidden: readonly string[], id: string): string[];
 export declare function moveColumn(order: readonly string[], ids: readonly (string | undefined)[], id: string, direction: -1 | 1): string[];
+/** Moves `id` to `index` in the resolved order, clamping `index` to the ends. */
+export declare function moveColumnTo(order: readonly string[], ids: readonly (string | undefined)[], id: string, index: number): string[];
 export declare function columnLabelMatches(label: string, query: string): boolean;

package/dist/controller/data-table-columns.js

@@ -1,73 +1,67 @@
+// src/controller/data-table-columns.ts
 function defaultDataTableStoreKey(resource) {
-  return `${resource}.datatable`;
+	return `${resource}.datatable`;
 }
 function dataTableColumnKeys(storeKey) {
-  return {
-    hidden: storeKey,
-    order: `${storeKey}_columnOrder`,
-    columns: `${storeKey}_columns`
-  };
+	return {
+		hidden: storeKey,
+		order: `${storeKey}_columnOrder`,
+		columns: `${storeKey}_columns`
+	};
 }
-function getDataTableColumnId({
-  source,
-  label
-}) {
-  if (typeof source === "string" && source !== "") return source;
-  if (typeof label === "string" && label !== "") return label;
-  return void 0;
+function getDataTableColumnId({ source, label }) {
+	if (typeof source === "string" && source !== "") return source;
+	if (typeof label === "string" && label !== "") return label;
 }
+/** The distinct ids in display order: the stored order first, then the rest as declared. */
 function resolveOrder(ids, order) {
-  const present = /* @__PURE__ */ new Set();
-  for (const id of ids) if (id !== void 0) present.add(id);
-  const resolved = /* @__PURE__ */ new Set();
-  for (const id of order) if (present.has(id)) resolved.add(id);
-  for (const id of present) resolved.add(id);
-  return [...resolved];
+	const present = /* @__PURE__ */ new Set();
+	for (const id of ids) if (id !== void 0) present.add(id);
+	const resolved = /* @__PURE__ */ new Set();
+	for (const id of order) if (present.has(id)) resolved.add(id);
+	for (const id of present) resolved.add(id);
+	return [...resolved];
 }
 function arrangeColumns(ids, { hidden, order }) {
-  const indexesById = /* @__PURE__ */ new Map();
-  ids.forEach((id, index) => {
-    if (id === void 0) return;
-    const indexes = indexesById.get(id);
-    if (indexes) indexes.push(index);
-    else indexesById.set(id, [index]);
-  });
-  const sequence = resolveOrder(ids, order).flatMap(
-    (id) => indexesById.get(id) ?? []
-  );
-  let next = 0;
-  const arranged = ids.map(
-    (id, index) => id === void 0 ? index : sequence[next++] ?? index
-  );
-  return arranged.filter((index) => {
-    const id = ids[index];
-    return id === void 0 || !hidden.includes(id);
-  });
+	const indexesById = /* @__PURE__ */ new Map();
+	ids.forEach((id, index) => {
+		if (id === void 0) return;
+		const indexes = indexesById.get(id);
+		if (indexes) indexes.push(index);
+		else indexesById.set(id, [index]);
+	});
+	const sequence = resolveOrder(ids, order).flatMap((id) => indexesById.get(id) ?? []);
+	let next = 0;
+	return ids.map((id, index) => id === void 0 ? index : sequence[next++] ?? index).filter((index) => {
+		const id = ids[index];
+		return id === void 0 || !hidden.includes(id);
+	});
 }
 function toggleHiddenColumn(hidden, id) {
-  return hidden.includes(id) ? hidden.filter((entry) => entry !== id) : [...hidden, id];
+	return hidden.includes(id) ? hidden.filter((entry) => entry !== id) : [...hidden, id];
 }
 function moveColumn(order, ids, id, direction) {
-  const resolved = resolveOrder(ids, order);
-  const from = resolved.indexOf(id);
-  const to = from + direction;
-  if (from < 0 || to < 0 || to >= resolved.length) return resolved;
-  resolved.splice(to, 0, ...resolved.splice(from, 1));
-  return resolved;
+	const resolved = resolveOrder(ids, order);
+	const from = resolved.indexOf(id);
+	const to = from + direction;
+	if (from < 0 || to < 0 || to >= resolved.length) return resolved;
+	resolved.splice(to, 0, ...resolved.splice(from, 1));
+	return resolved;
+}
+/** Moves `id` to `index` in the resolved order, clamping `index` to the ends. */
+function moveColumnTo(order, ids, id, index) {
+	const resolved = resolveOrder(ids, order);
+	const from = resolved.indexOf(id);
+	if (from < 0) return resolved;
+	const to = Math.min(Math.max(index, 0), resolved.length - 1);
+	resolved.splice(to, 0, ...resolved.splice(from, 1));
+	return resolved;
 }
 function fold(text) {
-  return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+	return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
 }
 function columnLabelMatches(label, query) {
-  if (query === "") return true;
-  return fold(label).includes(fold(query));
+	if (query === "") return true;
+	return fold(label).includes(fold(query));
 }
-export {
-  arrangeColumns,
-  columnLabelMatches,
-  dataTableColumnKeys,
-  defaultDataTableStoreKey,
-  getDataTableColumnId,
-  moveColumn,
-  toggleHiddenColumn
-};
+export { arrangeColumns, columnLabelMatches, dataTableColumnKeys, defaultDataTableStoreKey, getDataTableColumnId, moveColumn, moveColumnTo, toggleHiddenColumn };