@chelone/core 0.6.0 → 0.9.0

package/dist/data/fake-provider.js

@@ -1,122 +1,143 @@
+import { getAtPath } from "../resource/get-at-path.js";
+// src/data/fake-provider.ts
 function applyFilter(rows, filter) {
-  if (!filter) return rows;
-  return rows.filter(
-    (row) => Object.entries(filter).every(([key, value]) => row[key] === value)
-  );
+	if (!filter) return rows;
+	return rows.filter((row) => Object.entries(filter).every(([key, value]) => getAtPath(row, key) === value));
+}
+/** What `<` reduces a value to: dates by time, booleans and null as numbers. */
+function toComparable(value) {
+	if (value instanceof Date) return value.getTime();
+	if (typeof value === "number" || typeof value === "string") return value;
+	if (typeof value === "boolean") return Number(value);
+	if (value === null) return 0;
+	return NaN;
+}
+/**
+* Orders as `<` does, coercion included: null sorts as 0, a numeric string
+* against a number compares as a number, and values `<` cannot order
+* (undefined, objects, a non-numeric string against a number) tie.
+*/
+function compareValues(a, b) {
+	const x = toComparable(a);
+	const y = toComparable(b);
+	if (typeof x === "string" && typeof y === "string") {
+		if (x < y) return -1;
+		return x > y ? 1 : 0;
+	}
+	const nx = Number(x);
+	const ny = Number(y);
+	if (nx < ny) return -1;
+	return nx > ny ? 1 : 0;
 }
 function applySort(rows, sort) {
-  if (!sort) return rows;
-  const keys = Array.isArray(sort) ? sort : [sort];
-  if (keys.length === 0) return rows;
-  return [...rows].sort((a, b) => {
-    for (const { field, order } of keys) {
-      const dir = order === "ASC" ? 1 : -1;
-      const av = a[field];
-      const bv = b[field];
-      if (av < bv) return -dir;
-      if (av > bv) return dir;
-    }
-    return 0;
-  });
+	if (!sort) return rows;
+	const keys = Array.isArray(sort) ? sort : [sort];
+	if (keys.length === 0) return rows;
+	return [...rows].sort((a, b) => {
+		for (const { field, order } of keys) {
+			const dir = order === "ASC" ? 1 : -1;
+			const cmp = compareValues(getAtPath(a, field), getAtPath(b, field));
+			if (cmp !== 0) return cmp * dir;
+		}
+		return 0;
+	});
 }
 function paginate(rows, pagination) {
-  if (!pagination) return { data: rows, total: rows.length };
-  if ("page" in pagination) {
-    const start = (pagination.page - 1) * pagination.perPage;
-    return {
-      data: rows.slice(start, start + pagination.perPage),
-      total: rows.length
-    };
-  }
-  const offset = pagination.cursor === null ? 0 : Number(pagination.cursor);
-  const data = rows.slice(offset, offset + pagination.limit);
-  const next = offset + pagination.limit;
-  return {
-    data,
-    total: rows.length,
-    pageInfo: {
-      nextCursor: next < rows.length ? String(next) : null,
-      prevCursor: offset > 0 ? String(Math.max(0, offset - pagination.limit)) : null,
-      hasNextPage: next < rows.length,
-      hasPreviousPage: offset > 0
-    }
-  };
+	if (!pagination) return {
+		data: rows,
+		total: rows.length
+	};
+	if ("page" in pagination) {
+		const start = (pagination.page - 1) * pagination.perPage;
+		return {
+			data: rows.slice(start, start + pagination.perPage),
+			total: rows.length
+		};
+	}
+	const offset = pagination.cursor === null ? 0 : Number(pagination.cursor);
+	const data = rows.slice(offset, offset + pagination.limit);
+	const next = offset + pagination.limit;
+	return {
+		data,
+		total: rows.length,
+		pageInfo: {
+			nextCursor: next < rows.length ? String(next) : null,
+			prevCursor: offset > 0 ? String(Math.max(0, offset - pagination.limit)) : null,
+			hasNextPage: next < rows.length,
+			hasPreviousPage: offset > 0
+		}
+	};
 }
+/** In-memory DataProvider for tests and dogfooding. Mutates its own copy of the seed. */
 function fakeDataProvider(initialData) {
-  const store = /* @__PURE__ */ new Map();
-  for (const [resource, rows] of Object.entries(initialData)) {
-    store.set(resource, structuredClone(rows ?? []));
-  }
-  const table = (resource) => {
-    const rows = store.get(resource);
-    if (!rows)
-      throw new Error(`fakeDataProvider: unknown resource "${resource}"`);
-    return rows;
-  };
-  const find = (resource, id) => {
-    const row = table(resource).find((r) => String(r.id) === String(id));
-    if (!row)
-      throw new Error(`fakeDataProvider: ${resource}#${String(id)} not found`);
-    return row;
-  };
-  let nextId = 1e6;
-  const listLike = (rows, params) => paginate(
-    applySort(applyFilter(rows, params.filter), params.sort),
-    params.pagination
-  );
-  return {
-    async getList(resource, params) {
-      return listLike(table(resource), params);
-    },
-    async getOne(resource, params) {
-      return { data: structuredClone(find(resource, params.id)) };
-    },
-    async getMany(resource, params) {
-      return {
-        data: params.ids.map((id) => structuredClone(find(resource, id)))
-      };
-    },
-    async getManyReference(resource, params) {
-      const rows = table(resource).filter(
-        (r) => String(r[params.target]) === String(params.id)
-      );
-      return listLike(rows, params);
-    },
-    async create(resource, params) {
-      const row = { id: nextId++, ...structuredClone(params.data) };
-      table(resource).push(row);
-      return { data: structuredClone(row) };
-    },
-    async update(resource, params) {
-      const row = find(resource, params.id);
-      Object.assign(row, structuredClone(params.data));
-      return { data: structuredClone(row) };
-    },
-    async updateMany(resource, params) {
-      for (const id of params.ids)
-        Object.assign(find(resource, id), structuredClone(params.data));
-      return { data: params.ids };
-    },
-    async delete(resource, params) {
-      const rows = table(resource);
-      const idx = rows.findIndex((r) => String(r.id) === String(params.id));
-      if (idx === -1)
-        throw new Error(
-          `fakeDataProvider: ${resource}#${String(params.id)} not found`
-        );
-      const [removed] = rows.splice(idx, 1);
-      return { data: structuredClone(removed) };
-    },
-    async deleteMany(resource, params) {
-      for (const id of params.ids) {
-        const rows = table(resource);
-        const idx = rows.findIndex((r) => String(r.id) === String(id));
-        if (idx !== -1) rows.splice(idx, 1);
-      }
-      return { data: params.ids };
-    }
-  };
+	const store = structuredClone(initialData);
+	const table = (resource) => {
+		const rows = store[resource];
+		if (rows) return rows;
+		if (!Object.hasOwn(store, resource)) throw new Error(`fakeDataProvider: unknown resource "${resource}"`);
+		const empty = [];
+		store[resource] = empty;
+		return empty;
+	};
+	const find = (resource, id) => {
+		const row = table(resource).find((r) => String(r.id) === String(id));
+		if (!row) throw new Error(`fakeDataProvider: ${resource}#${String(id)} not found`);
+		return row;
+	};
+	let nextId = 1e6;
+	const listLike = (rows, params) => {
+		const page = paginate(applySort(applyFilter(rows, params.filter), params.sort), params.pagination);
+		return {
+			...page,
+			data: structuredClone(page.data)
+		};
+	};
+	return {
+		async getList(resource, params) {
+			return listLike(table(resource), params);
+		},
+		async getOne(resource, params) {
+			return { data: structuredClone(find(resource, params.id)) };
+		},
+		async getMany(resource, params) {
+			return { data: params.ids.map((id) => structuredClone(find(resource, id))) };
+		},
+		async getManyReference(resource, params) {
+			const rows = table(resource).filter((r) => String(getAtPath(r, params.target)) === String(params.id));
+			return listLike(rows, params);
+		},
+		async create(resource, params) {
+			const row = {
+				id: nextId++,
+				...structuredClone(params.data)
+			};
+			table(resource).push(row);
+			return { data: structuredClone(row) };
+		},
+		async update(resource, params) {
+			const row = find(resource, params.id);
+			Object.assign(row, structuredClone(params.data));
+			return { data: structuredClone(row) };
+		},
+		async updateMany(resource, params) {
+			for (const id of params.ids) Object.assign(find(resource, id), structuredClone(params.data));
+			return { data: params.ids };
+		},
+		async delete(resource, params) {
+			const rows = table(resource);
+			const idx = rows.findIndex((r) => String(r.id) === String(params.id));
+			const removed = idx === -1 ? void 0 : rows.splice(idx, 1)[0];
+			if (!removed) throw new Error(`fakeDataProvider: ${resource}#${String(params.id)} not found`);
+			return { data: structuredClone(removed) };
+		},
+		async deleteMany(resource, params) {
+			for (const id of params.ids) {
+				const rows = table(resource);
+				const idx = rows.findIndex((r) => String(r.id) === String(id));
+				if (idx !== -1) rows.splice(idx, 1);
+			}
+			return { data: params.ids };
+		}
+	};
 }
-export {
-  fakeDataProvider
-};
+export { fakeDataProvider };

package/dist/data/fetch-utils.js

@@ -1,56 +1,73 @@
 import { HttpError } from "./http-error.js";
+// src/data/fetch-utils.ts
 function parseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
 }
 function errorMessage(json, response) {
-  const message = json != null && typeof json === "object" ? json.message : void 0;
-  if (typeof message === "string") return message;
-  return response.statusText || `HTTP ${response.status}`;
+	const message = json != null && typeof json === "object" ? json.message : void 0;
+	if (typeof message === "string") return message;
+	return response.statusText || `HTTP ${response.status}`;
 }
+/**
+* A thin call to the global `fetch`.
+*
+* - Resolves `{ status, statusText, headers, body, json }` on a 2xx; `json` is
+*   `undefined` when the text is not JSON.
+* - Rejects a non-2xx with an `HttpError` whose `body` is the parsed JSON.
+* - Rejects a network failure with the error `fetch` threw, unchanged.
+* - Sets `Accept: application/json`, and `Content-Type: application/json` for
+*   a string `body` when the caller set none.
+* - A non-empty `token` is sent as `Authorization: Bearer <token>` and wins
+*   over an `Authorization` header in `options.headers`; an empty one is
+*   ignored.
+*/
 async function fetchJson(url, options = {}) {
-  const { token, ...init } = options;
-  const headers = new Headers(init.headers);
-  if (!headers.has("Accept")) headers.set("Accept", "application/json");
-  if (typeof init.body === "string" && !headers.has("Content-Type")) {
-    headers.set("Content-Type", "application/json");
-  }
-  if (token) headers.set("Authorization", `Bearer ${token}`);
-  const response = await fetch(url, { ...init, headers });
-  const body = await response.text();
-  const json = parseJson(body);
-  if (!response.ok) {
-    throw new HttpError(errorMessage(json, response), response.status, json);
-  }
-  return {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers,
-    body,
-    json
-  };
+	const { token, ...init } = options;
+	const headers = new Headers(init.headers);
+	if (!headers.has("Accept")) headers.set("Accept", "application/json");
+	if (typeof init.body === "string" && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+	if (token) headers.set("Authorization", `Bearer ${token}`);
+	const response = await fetch(url, {
+		...init,
+		headers
+	});
+	const body = await response.text();
+	const json = parseJson(body);
+	if (!response.ok) throw new HttpError(errorMessage(json, response), response.status, json);
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers,
+		body,
+		json
+	};
 }
 function encodeValue(value) {
-  if (value instanceof Date) return value.toISOString();
-  return typeof value === "object" ? JSON.stringify(value) : String(value);
+	if (value instanceof Date) return value.toISOString();
+	return typeof value === "object" ? JSON.stringify(value) : String(value);
 }
+/**
+* Builds a query string (no leading `?`). Skips `undefined` and `null`,
+* repeats the key for an array, writes a `Date` as its ISO string and
+* JSON-encodes any other object.
+*/
 function queryParameters(params) {
-  const parts = [];
-  for (const [key, value] of Object.entries(params)) {
-    const values = Array.isArray(value) ? value : [value];
-    for (const item of values) {
-      if (item === void 0 || item === null) continue;
-      parts.push(
-        `${encodeURIComponent(key)}=${encodeURIComponent(encodeValue(item))}`
-      );
-    }
-  }
-  return parts.join("&");
+	const parts = [];
+	for (const [key, value] of Object.entries(params)) {
+		const values = Array.isArray(value) ? value : [value];
+		for (const item of values) {
+			if (item === void 0 || item === null) continue;
+			parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(encodeValue(item))}`);
+		}
+	}
+	return parts.join("&");
 }
-const fetchUtils = { fetchJson, queryParameters };
-export {
-  fetchUtils
+var fetchUtils = {
+	fetchJson,
+	queryParameters
 };
+export { fetchUtils };

package/dist/data/filter-branch.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Does a filter value nest, so a walker descends into it? An object that is
+ * not an array and not a Date. Not the prototype check: a class instance nests.
+ */
+export declare function isFilterBranch(value: unknown): value is Record<string, unknown>;

package/dist/data/filter-branch.js

@@ -0,0 +1,10 @@
+import { isRecord } from "../guards.js";
+// src/data/filter-branch.ts
+/**
+* Does a filter value nest, so a walker descends into it? An object that is
+* not an array and not a Date. Not the prototype check: a class instance nests.
+*/
+function isFilterBranch(value) {
+	return isRecord(value) && !(value instanceof Date);
+}
+export { isFilterBranch };

package/dist/data/get-many-aggregate.js

@@ -1,85 +1,93 @@
-import { hashKey } from "@tanstack/query-core";
 import { manyKey, oneKey } from "./keys.js";
-const pending = /* @__PURE__ */ new WeakMap();
+import { hashKey } from "@tanstack/query-core";
+// src/data/get-many-aggregate.ts
+/**
+* One pending batch per resource and meta, per provider. A flushed batch leaves
+* the map. Contexts that share a provider share a batch, so the flush seeds the
+* cache of every caller's `queryClient`.
+*/
+var pending = /* @__PURE__ */ new WeakMap();
 function flush(ctx, batchKey, batch) {
-  pending.get(ctx.dataProvider)?.delete(batchKey);
-  void settle(ctx, batch);
+	pending.get(ctx.dataProvider)?.delete(batchKey);
+	settle(ctx, batch);
 }
+/**
+* Every failure on the way, a synchronous throw from the provider or a
+* malformed result included, rejects the whole batch. Rejecting a caller that
+* already resolved is a no-op.
+*/
 async function settle(ctx, batch) {
-  try {
-    const provider = ctx.dataProvider;
-    const params = { ids: [...batch.ids.values()] };
-    if (batch.meta !== void 0) params.meta = batch.meta;
-    const result = await provider.getMany(batch.resource, params);
-    const queryClients = new Set(batch.callers.map((c) => c.queryClient));
-    const byId = /* @__PURE__ */ new Map();
-    for (const record of result.data) {
-      byId.set(String(record.id), record);
-      for (const queryClient of queryClients) {
-        queryClient.setQueryData(
-          oneKey(batch.resource, { id: record.id }),
-          record
-        );
-      }
-    }
-    for (const caller of batch.callers) {
-      const own = /* @__PURE__ */ new Map();
-      for (const id of caller.ids) {
-        const record = byId.get(String(id));
-        if (record) own.set(String(id), record);
-      }
-      caller.resolve([...own.values()]);
-    }
-  } catch (error) {
-    for (const caller of batch.callers) caller.reject(error);
-  }
+	try {
+		const provider = ctx.dataProvider;
+		const params = { ids: [...batch.ids.values()] };
+		if (batch.meta !== void 0) params.meta = batch.meta;
+		const result = await provider.getMany(batch.resource, params);
+		const queryClients = new Set(batch.callers.map((c) => c.queryClient));
+		const byId = /* @__PURE__ */ new Map();
+		for (const record of result.data) {
+			byId.set(String(record.id), record);
+			for (const queryClient of queryClients) queryClient.setQueryData(oneKey(batch.resource, { id: record.id }), record);
+		}
+		for (const caller of batch.callers) {
+			const own = /* @__PURE__ */ new Map();
+			for (const id of caller.ids) {
+				const record = byId.get(String(id));
+				if (record) own.set(String(id), record);
+			}
+			caller.resolve([...own.values()]);
+		}
+	} catch (error) {
+		for (const caller of batch.callers) caller.reject(error);
+	}
 }
+/**
+* Joins the pending batch for this provider, resource and `meta`, opening it
+* and scheduling its `setTimeout(0)` flush if there is none. Resolves once the
+* flush has the provider's answer, with this caller's own records in its own id
+* order, repeated ids once and ids the provider omitted left out. Rejects with
+* the batch's error.
+*/
 function enqueue(ctx, resource, params) {
-  const batchKey = hashKey([resource, { meta: params.meta }]);
-  let batches = pending.get(ctx.dataProvider);
-  if (!batches) {
-    batches = /* @__PURE__ */ new Map();
-    pending.set(ctx.dataProvider, batches);
-  }
-  let batch = batches.get(batchKey);
-  if (!batch) {
-    const created = {
-      resource,
-      meta: params.meta,
-      ids: /* @__PURE__ */ new Map(),
-      callers: []
-    };
-    batch = created;
-    batches.set(batchKey, created);
-    setTimeout(() => flush(ctx, batchKey, created), 0);
-  }
-  for (const id of params.ids) {
-    if (!batch.ids.has(String(id))) batch.ids.set(String(id), id);
-  }
-  const target = batch;
-  return new Promise((resolve, reject) => {
-    target.callers.push({
-      queryClient: ctx.queryClient,
-      ids: [...params.ids],
-      resolve,
-      reject
-    });
-  });
+	const batchKey = hashKey([resource, { meta: params.meta }]);
+	let batches = pending.get(ctx.dataProvider);
+	if (!batches) {
+		batches = /* @__PURE__ */ new Map();
+		pending.set(ctx.dataProvider, batches);
+	}
+	let batch = batches.get(batchKey);
+	if (!batch) {
+		const created = {
+			resource,
+			meta: params.meta,
+			ids: /* @__PURE__ */ new Map(),
+			callers: []
+		};
+		batch = created;
+		batches.set(batchKey, created);
+		setTimeout(() => flush(ctx, batchKey, created), 0);
+	}
+	for (const id of params.ids) if (!batch.ids.has(String(id))) batch.ids.set(String(id), id);
+	const target = batch;
+	return new Promise((resolve, reject) => {
+		target.callers.push({
+			queryClient: ctx.queryClient,
+			ids: [...params.ids],
+			resolve,
+			reject
+		});
+	});
 }
+/**
+* Same signature and result as `getManyOptions`, but reads started in the same
+* tick reach the data provider as one `getMany` per resource and `meta`.
+*/
 function getManyAggregateOptions(ctx, resource, params) {
-  return {
-    queryKey: manyKey(resource, params),
-    queryFn: async () => {
-      if (params.ids.length === 0) return [];
-      const records = await enqueue(
-        ctx,
-        resource,
-        params
-      );
-      return records;
-    }
-  };
+	return {
+		queryKey: manyKey(resource, params),
+		queryFn: async () => {
+			if (params.ids.length === 0) return [];
+			return await enqueue(ctx, resource, params);
+		}
+	};
 }
-export {
-  getManyAggregateOptions
-};
+export { getManyAggregateOptions };

package/dist/data/http-error.js

@@ -1,13 +1,18 @@
-class HttpError extends Error {
-  name = "HttpError";
-  status;
-  body;
-  constructor(message, status, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-  }
-}
-export {
-  HttpError
+// src/data/http-error.ts
+/**
+* Rejected by `fetchUtils.fetchJson` on a non-2xx response. `status` is what
+* `authProvider.checkError` reads to log a user out on 401/403; `body` is the
+* parsed response body (a provider maps a 422 onto `ValidationError` from it).
+* Framework-free by design.
+*/
+var HttpError = class extends Error {
+	name = "HttpError";
+	status;
+	body;
+	constructor(message, status, body) {
+		super(message);
+		this.status = status;
+		this.body = body;
+	}
 };
+export { HttpError };