@chelone/core 0.6.0 → 0.9.0

package/dist/controller/saved-queries.js

@@ -1,104 +1,117 @@
+import { isPlainObject, isRecord } from "../guards.js";
 import { createMicroStore } from "../store/micro-store.js";
+// src/controller/saved-queries.ts
+/** The key ra-core's `useSavedQueries` uses. */
 function savedQueriesKey(storeKey) {
-  return `${storeKey}.savedQueries`;
+	return `${storeKey}.savedQueries`;
 }
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const isSortPayload = (value) => isRecord(value) && typeof value.field === "string" && (value.order === "ASC" || value.order === "DESC");
+var isSortPayload = (value) => isRecord(value) && typeof value.field === "string" && (value.order === "ASC" || value.order === "DESC");
 function isSavedQueryValue(value) {
-  return isRecord(value) && isRecord(value.filter) && isRecord(value.displayedFilters) && Object.values(value.displayedFilters).every(
-    (flag) => typeof flag === "boolean"
-  ) && Array.isArray(value.sort) && value.sort.every(isSortPayload) && typeof value.perPage === "number" && Number.isInteger(value.perPage) && value.perPage > 0;
+	return isRecord(value) && isRecord(value.filter) && isRecord(value.displayedFilters) && Object.values(value.displayedFilters).every((flag) => typeof flag === "boolean") && Array.isArray(value.sort) && value.sort.every(isSortPayload) && typeof value.perPage === "number" && Number.isInteger(value.perPage) && value.perPage > 0;
 }
+/**
+* Reads whatever storage holds: non-arrays give `[]`, malformed entries are
+* dropped, labels are trimmed, and a repeated label keeps its first entry.
+*/
 function extractValidSavedQueries(raw) {
-  if (!Array.isArray(raw)) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const queries = [];
-  for (const entry of raw) {
-    if (!isRecord(entry) || typeof entry.label !== "string") continue;
-    const label = entry.label.trim();
-    if (!label || seen.has(label) || !isSavedQueryValue(entry.value)) continue;
-    seen.add(label);
-    queries.push({ label, value: entry.value });
-  }
-  return queries;
+	if (!Array.isArray(raw)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const queries = [];
+	for (const entry of raw) {
+		if (!isRecord(entry) || typeof entry.label !== "string") continue;
+		const label = entry.label.trim();
+		if (!label || seen.has(label) || !isSavedQueryValue(entry.value)) continue;
+		seen.add(label);
+		queries.push({
+			label,
+			value: entry.value
+		});
+	}
+	return queries;
 }
-const isPlainObject = (value) => {
-  if (!isRecord(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-};
+/**
+* Structural equality; object key order is irrelevant, array order is not.
+* Only plain objects, arrays and dates compare by content: any other class
+* instance is equal to itself alone.
+*/
 function isDeepEqual(a, b) {
-  if (Object.is(a, b)) return true;
-  if (a instanceof Date || b instanceof Date) {
-    return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
-  }
-  if (Array.isArray(a) || Array.isArray(b)) {
-    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => isDeepEqual(item, b[index]));
-  }
-  if (!isPlainObject(a) || !isPlainObject(b)) return false;
-  const keys = Object.keys(a);
-  return keys.length === Object.keys(b).length && keys.every((key) => key in b && isDeepEqual(a[key], b[key]));
+	if (Object.is(a, b)) return true;
+	if (a instanceof Date || b instanceof Date) return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => isDeepEqual(item, b[index]));
+	if (!isPlainObject(a) || !isPlainObject(b)) return false;
+	const keys = Object.keys(a);
+	return keys.length === Object.keys(b).length && keys.every((key) => key in b && isDeepEqual(a[key], b[key]));
 }
+/** Whether `current` list params are the saved query. `displayedFilters` is ignored. */
 function isSavedQueryActive(query, current) {
-  return query.perPage === current.perPage && isDeepEqual(query.sort, current.sort) && isDeepEqual(query.filter, current.filter);
+	return query.perPage === current.perPage && isDeepEqual(query.sort, current.sort) && isDeepEqual(query.filter, current.filter);
 }
+/**
+* Named filter/sort sets persisted in the KV store.
+*
+* Lifecycle (Task 4R): construction is inert. The first subscriber subscribes
+* to the store key and re-reads it; the last unsubscribe releases it. Detached,
+* a write still updates local state, and the next attach picks up whatever the
+* store holds.
+*/
 function createSavedQueriesController(ctx, resource, options = {}) {
-  const key = savedQueriesKey(options.storeKey ?? resource);
-  const kv = ctx.store;
-  let lastRaw = kv?.getItem(key);
-  const store = createMicroStore(
-    { queries: extractValidSavedQueries(lastRaw) },
-    {
-      onSubscribed: () => {
-        if (!kv) return;
-        resync();
-        return kv.subscribe(key, resync);
-      }
-    }
-  );
-  function resync() {
-    if (!kv) return;
-    const raw = kv.getItem(key);
-    if (raw === lastRaw) return;
-    lastRaw = raw;
-    const queries = extractValidSavedQueries(raw);
-    if (isDeepEqual(queries, store.getSnapshot().queries)) return;
-    store.setState({ queries });
-  }
-  const current = () => {
-    resync();
-    return store.getSnapshot().queries;
-  };
-  const write = (queries) => {
-    if (!kv) {
-      store.setState({ queries });
-      return;
-    }
-    kv.setItem(key, queries);
-    resync();
-  };
-  const save = (label, value) => {
-    const trimmed = label.trim();
-    if (!trimmed) return;
-    if (!isSavedQueryValue(value)) return;
-    const next = { label: trimmed, value: structuredClone(value) };
-    const queries = current();
-    const index = queries.findIndex((query) => query.label === trimmed);
-    write(
-      index === -1 ? [...queries, next] : queries.map((query, i) => i === index ? next : query)
-    );
-  };
-  const remove = (label) => {
-    const trimmed = label.trim();
-    const queries = current();
-    if (!queries.some((query) => query.label === trimmed)) return;
-    write(queries.filter((query) => query.label !== trimmed));
-  };
-  return { ...store, save, remove };
+	const key = savedQueriesKey(options.storeKey ?? resource);
+	const kv = ctx.store;
+	/** The raw value the state was last derived from, to skip no-op resyncs. */
+	let lastRaw = kv?.getItem(key);
+	const store = createMicroStore({ queries: extractValidSavedQueries(lastRaw) }, { onSubscribed: () => {
+		if (!kv) return;
+		resync();
+		return kv.subscribe(key, resync);
+	} });
+	/** Brings state in line with the store; a no-op when nothing changed. */
+	function resync() {
+		if (!kv) return;
+		const raw = kv.getItem(key);
+		if (raw === lastRaw) return;
+		lastRaw = raw;
+		const queries = extractValidSavedQueries(raw);
+		if (isDeepEqual(queries, store.getSnapshot().queries)) return;
+		store.setState({ queries });
+	}
+	/**
+	* Detached, nothing keeps state current, so every action starts from the
+	* store: a stale snapshot would write over another controller's queries.
+	*/
+	const current = () => {
+		resync();
+		return store.getSnapshot().queries;
+	};
+	const write = (queries) => {
+		if (!kv) {
+			store.setState({ queries });
+			return;
+		}
+		kv.setItem(key, queries);
+		resync();
+	};
+	const save = (label, value) => {
+		const trimmed = label.trim();
+		if (!trimmed) return;
+		if (!isSavedQueryValue(value)) return;
+		const next = {
+			label: trimmed,
+			value: structuredClone(value)
+		};
+		const queries = current();
+		const index = queries.findIndex((query) => query.label === trimmed);
+		write(index === -1 ? [...queries, next] : queries.map((query, i) => i === index ? next : query));
+	};
+	const remove = (label) => {
+		const trimmed = label.trim();
+		const queries = current();
+		if (!queries.some((query) => query.label === trimmed)) return;
+		write(queries.filter((query) => query.label !== trimmed));
+	};
+	return {
+		...store,
+		save,
+		remove
+	};
 }
-export {
-  createSavedQueriesController,
-  extractValidSavedQueries,
-  isSavedQueryActive,
-  savedQueriesKey
-};
+export { createSavedQueriesController, extractValidSavedQueries, isSavedQueryActive, savedQueriesKey };

package/dist/controller/translate-fallback.js

@@ -1,8 +1,12 @@
+// src/controller/translate-fallback.ts
+/**
+* Resource-scoped notification key with global fallback. A translator that
+* returns the key unchanged (Chelone i18n's missing-key behavior) means
+* "not translated" — fall back to the global key.
+*/
 function resolveNotificationKey(translate, resource, event) {
-  const scoped = `resources.${resource}.notifications.${event}`;
-  if (translate && translate(scoped) !== scoped) return scoped;
-  return `chelone.notification.${event}`;
+	const scoped = `resources.${resource}.notifications.${event}`;
+	if (translate && translate(scoped) !== scoped) return scoped;
+	return `chelone.notification.${event}`;
 }
-export {
-  resolveNotificationKey
-};
+export { resolveNotificationKey };

package/dist/csv/export.d.ts

@@ -18,19 +18,20 @@
  * passes its own `exporter` prop — the button never assumes the default.
  */
 import type { DataProvider } from "../data/types.js";
-import type { LooseRecord } from "../resource/record.js";
+import type { LooseRecord, ResourceRecord } from "../resource/record.js";
+import type { CsvRow } from "./types.js";
 /**
  * Turns a page of records into a downloaded file. Called by the export buttons
  * with the fetched rows, the raw dataProvider (for follow-up fetches), and the
  * resource name.
  */
-export type Exporter<TRecord extends LooseRecord = LooseRecord> = (data: TRecord[], dataProvider: DataProvider, resource: string) => void | Promise<void>;
+export type Exporter<TRecord extends ResourceRecord = LooseRecord> = (data: TRecord[], dataProvider: DataProvider, resource: string) => void | Promise<void>;
 /**
  * Serialize records to CSV text. Columns are the UNION of every record's keys,
  * in first-seen order — so a sparse record still lines up under the right
  * header. Returns an empty string for an empty dataset.
  */
-export declare function recordsToCSV(data: readonly LooseRecord[]): string;
+export declare function recordsToCSV(data: readonly CsvRow[]): string;
 /**
  * Trigger a browser download of `csv` as `<filename>.csv`. A DOM-guarded no-op
  * when there is no `document` (SSR / non-jsdom test env) so callers never crash

package/dist/csv/export.js

@@ -1,47 +1,50 @@
+// src/csv/export.ts
+/** Escape one CSV cell: wrap in quotes + double any embedded quote when needed. */
 function csvCell(value) {
-  if (value == null) return "";
-  const raw = typeof value === "object" ? JSON.stringify(value) : String(value);
-  if (/[",\n\r]/.test(raw)) {
-    return `"${raw.replace(/"/g, '""')}"`;
-  }
-  return raw;
+	if (value == null) return "";
+	const raw = typeof value === "object" ? JSON.stringify(value) : String(value);
+	if (/[",\n\r]/.test(raw)) return `"${raw.replace(/"/g, "\"\"")}"`;
+	return raw;
 }
+/**
+* Serialize records to CSV text. Columns are the UNION of every record's keys,
+* in first-seen order — so a sparse record still lines up under the right
+* header. Returns an empty string for an empty dataset.
+*/
 function recordsToCSV(data) {
-  if (data.length === 0) return "";
-  const columns = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const record of data) {
-    for (const key of Object.keys(record)) {
-      if (!seen.has(key)) {
-        seen.add(key);
-        columns.push(key);
-      }
-    }
-  }
-  const header = columns.map(csvCell).join(",");
-  const rows = data.map(
-    (record) => columns.map((col) => csvCell(record[col])).join(",")
-  );
-  return [header, ...rows].join("\n");
+	if (data.length === 0) return "";
+	const columns = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const record of data) for (const key of Object.keys(record)) if (!seen.has(key)) {
+		seen.add(key);
+		columns.push(key);
+	}
+	return [columns.map(csvCell).join(","), ...data.map((record) => columns.map((col) => csvCell(record[col])).join(","))].join("\n");
 }
+/**
+* Trigger a browser download of `csv` as `<filename>.csv`. A DOM-guarded no-op
+* when there is no `document` (SSR / non-jsdom test env) so callers never crash
+* off-DOM.
+*/
 function downloadCSV(csv, filename) {
-  if (typeof document === "undefined") return;
-  const blob = new Blob([csv], { type: "text/csv;charset=utf-8" });
-  const url = URL.createObjectURL(blob);
-  const link = document.createElement("a");
-  link.href = url;
-  link.download = `${filename}.csv`;
-  link.style.display = "none";
-  document.body.appendChild(link);
-  link.click();
-  document.body.removeChild(link);
-  setTimeout(() => URL.revokeObjectURL(url), 0);
+	if (typeof document === "undefined") return;
+	const blob = new Blob([csv], { type: "text/csv;charset=utf-8" });
+	const url = URL.createObjectURL(blob);
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = `${filename}.csv`;
+	link.style.display = "none";
+	document.body.appendChild(link);
+	link.click();
+	document.body.removeChild(link);
+	setTimeout(() => URL.revokeObjectURL(url), 0);
 }
-const defaultExporter = (data, _dataProvider, resource) => {
-  downloadCSV(recordsToCSV(data), resource);
-};
-export {
-  defaultExporter,
-  downloadCSV,
-  recordsToCSV
+/**
+* The built-in exporter: serialize `data` to CSV (union-of-keys columns) and
+* download it as `<resource>.csv`. Apps needing nested/related data pass a
+* custom `exporter` prop instead.
+*/
+var defaultExporter = (data, _dataProvider, resource) => {
+	downloadCSV(recordsToCSV(data), resource);
 };
+export { defaultExporter, downloadCSV, recordsToCSV };

package/dist/csv/import-controller.d.ts

@@ -1,5 +1,9 @@
 import { type MicroStore } from "../store/micro-store.js";
 import type { CsvImportOptions, CsvImportState, ParsedCsv } from "./types.js";
+/** How many rows either adapter's preview step lists. */
+export declare const PREVIEW_ROWS = 50;
+/** What `readAsText` writes for each byte it cannot read as UTF-8. */
+export declare const REPLACEMENT_CHAR = "\uFFFD";
 export interface CsvImportController {
     store: MicroStore<CsvImportState>;
     /** Takes the file the adapter parsed. Does nothing while an import runs. */