@chelone/core 0.6.0 → 0.7.0

package/dist/resource/describe-resource.js

@@ -1,246 +1,259 @@
-const bagOf = (value) => typeof value === "object" && value !== null ? value : void 0;
-const stripZod = (typeName) => typeName.replace(/^Zod/, "").toLowerCase();
-const formatsOf = (checks, format) => {
-  const formats = /* @__PURE__ */ new Set();
-  if (typeof format === "string") formats.add(format);
-  if (Array.isArray(checks)) {
-    for (const check of checks) {
-      const legacy = bagOf(check)?.kind;
-      const modern = bagOf(bagOf(bagOf(check)?._zod)?.def)?.format;
-      for (const found of [legacy, modern]) {
-        if (typeof found === "string") formats.add(found);
-      }
-    }
-  }
-  return formats;
+// src/resource/describe-resource.ts
+var bagOf = (value) => typeof value === "object" && value !== null ? value : void 0;
+var stripZod = (typeName) => typeName.replace(/^Zod/, "").toLowerCase();
+var formatsOf = (checks, format) => {
+	const formats = /* @__PURE__ */ new Set();
+	if (typeof format === "string") formats.add(format);
+	if (Array.isArray(checks)) for (const check of checks) {
+		const legacy = bagOf(check)?.kind;
+		const modern = bagOf(bagOf(bagOf(check)?._zod)?.def)?.format;
+		for (const found of [legacy, modern]) if (typeof found === "string") formats.add(found);
+	}
+	return formats;
 };
 function readZod3(def) {
-  const typeName = typeof def.typeName === "string" ? def.typeName : "";
-  const node = {
-    type: stripZod(typeName),
-    formats: formatsOf(def.checks, void 0)
-  };
-  switch (typeName) {
-    case "ZodOptional":
-    case "ZodNullable":
-    case "ZodDefault":
-    case "ZodCatch":
-    case "ZodReadonly":
-      node.inner = def.innerType;
-      break;
-    case "ZodBranded":
-      node.inner = def.type;
-      break;
-    case "ZodEffects":
-      node.inner = def.schema;
-      break;
-    case "ZodPipeline":
-      node.inner = def.in;
-      break;
-    case "ZodEnum":
-      node.entries = Object.fromEntries(
-        def.values.map((value) => [value, value])
-      );
-      break;
-    case "ZodNativeEnum":
-      node.type = "enum";
-      node.entries = def.values;
-      break;
-    case "ZodUnion":
-      node.options = def.options;
-      break;
-    case "ZodLiteral":
-      node.value = def.value;
-      break;
-    case "ZodArray":
-      node.element = def.type;
-      break;
-    case "ZodObject":
-      if (typeof def.shape === "function") {
-        node.shape = def.shape();
-      }
-      break;
-  }
-  return node;
+	const typeName = typeof def.typeName === "string" ? def.typeName : "";
+	const node = {
+		type: stripZod(typeName),
+		formats: formatsOf(def.checks, void 0)
+	};
+	switch (typeName) {
+		case "ZodOptional":
+		case "ZodNullable":
+		case "ZodDefault":
+		case "ZodCatch":
+		case "ZodReadonly":
+			node.inner = def.innerType;
+			break;
+		case "ZodBranded":
+			node.inner = def.type;
+			break;
+		case "ZodEffects":
+			node.inner = def.schema;
+			break;
+		case "ZodPipeline":
+			node.inner = def.in;
+			break;
+		case "ZodEnum":
+			node.entries = Object.fromEntries(def.values.map((value) => [value, value]));
+			break;
+		case "ZodNativeEnum":
+			node.type = "enum";
+			node.entries = def.values;
+			break;
+		case "ZodUnion":
+			node.options = def.options;
+			break;
+		case "ZodLiteral":
+			node.value = def.value;
+			break;
+		case "ZodArray":
+			node.element = def.type;
+			break;
+		case "ZodObject": if (typeof def.shape === "function") node.shape = def.shape();
+	}
+	return node;
 }
 function readZod4(def) {
-  const type = typeof def.type === "string" ? def.type : "";
-  const node = {
-    type,
-    formats: formatsOf(def.checks, def.format)
-  };
-  switch (type) {
-    case "optional":
-    case "nullable":
-    case "nonoptional":
-    case "default":
-    case "prefault":
-    case "catch":
-    case "readonly":
-      node.inner = def.innerType;
-      break;
-    case "pipe": {
-      const into = bagOf(bagOf(bagOf(def.in)?._zod)?.def)?.type;
-      node.inner = into === "transform" ? def.out : def.in;
-      break;
-    }
-    case "enum":
-      node.entries = def.entries;
-      break;
-    case "union":
-      node.options = def.options;
-      break;
-    case "literal":
-      node.value = def.values?.[0];
-      if (def.values?.length !== 1) {
-        node.type = "literals";
-      }
-      break;
-    case "array":
-      node.element = def.element;
-      break;
-    case "object":
-      node.shape = def.shape;
-      break;
-  }
-  return node;
+	const type = typeof def.type === "string" ? def.type : "";
+	const node = {
+		type,
+		formats: formatsOf(def.checks, def.format)
+	};
+	switch (type) {
+		case "optional":
+		case "nullable":
+		case "nonoptional":
+		case "default":
+		case "prefault":
+		case "catch":
+		case "readonly":
+			node.inner = def.innerType;
+			break;
+		case "pipe":
+			node.inner = bagOf(bagOf(bagOf(def.in)?._zod)?.def)?.type === "transform" ? def.out : def.in;
+			break;
+		case "enum":
+			node.entries = def.entries;
+			break;
+		case "union":
+			node.options = def.options;
+			break;
+		case "literal":
+			node.value = def.values?.[0];
+			if (def.values?.length !== 1) node.type = "literals";
+			break;
+		case "array":
+			node.element = def.element;
+			break;
+		case "object": node.shape = def.shape;
+	}
+	return node;
 }
 function read(schema) {
-  const zod4 = bagOf(bagOf(bagOf(schema)?._zod)?.def);
-  if (zod4) return readZod4(zod4);
-  const zod3 = bagOf(bagOf(schema)?._def);
-  if (zod3) return readZod3(zod3);
-  return { type: "unknown", formats: /* @__PURE__ */ new Set() };
+	const zod4 = bagOf(bagOf(bagOf(schema)?._zod)?.def);
+	if (zod4) return readZod4(zod4);
+	const zod3 = bagOf(bagOf(schema)?._def);
+	if (zod3) return readZod3(zod3);
+	return {
+		type: "unknown",
+		formats: /* @__PURE__ */ new Set()
+	};
 }
-const descriptionOf = (schema) => {
-  const description = bagOf(schema)?.description;
-  return typeof description === "string" ? description : void 0;
+var descriptionOf = (schema) => {
+	const description = bagOf(schema)?.description;
+	return typeof description === "string" ? description : void 0;
 };
 function unwrap(schema) {
-  let current = schema;
-  let label;
-  for (let depth = 0; depth < 64; depth++) {
-    const node = read(current);
-    label ??= descriptionOf(current);
-    if (node.inner === void 0) return { node, label };
-    current = node.inner;
-  }
-  return { node: read(current), label };
+	let current = schema;
+	let label;
+	for (let depth = 0; depth < 64; depth++) {
+		const node = read(current);
+		label ??= descriptionOf(current);
+		if (node.inner === void 0) return {
+			node,
+			label
+		};
+		current = node.inner;
+	}
+	return {
+		node: read(current),
+		label
+	};
 }
-const unsupported = (reason) => ({
-  kind: "unsupported",
-  reason
+var unsupported = (reason) => ({
+	kind: "unsupported",
+	reason
 });
 function describeString({ formats }) {
-  if (formats.has("datetime")) {
-    return {
-      kind: "dateTime",
-      field: "DateField",
-      input: "DateTimeInput",
-      fieldProps: { showTime: true }
-    };
-  }
-  if (formats.has("date")) {
-    return { kind: "date", field: "DateField", input: "DateInput" };
-  }
-  if (formats.has("email")) {
-    return { kind: "email", field: "EmailField", input: "TextInput" };
-  }
-  if (formats.has("url")) {
-    return { kind: "url", field: "UrlField", input: "TextInput" };
-  }
-  return { kind: "text", field: "TextField", input: "TextInput" };
+	if (formats.has("datetime")) return {
+		kind: "dateTime",
+		field: "DateField",
+		input: "DateTimeInput",
+		fieldProps: { showTime: true }
+	};
+	if (formats.has("date")) return {
+		kind: "date",
+		field: "DateField",
+		input: "DateInput"
+	};
+	if (formats.has("email")) return {
+		kind: "email",
+		field: "EmailField",
+		input: "TextInput"
+	};
+	if (formats.has("url")) return {
+		kind: "url",
+		field: "UrlField",
+		input: "TextInput"
+	};
+	return {
+		kind: "text",
+		field: "TextField",
+		input: "TextInput"
+	};
 }
 function select(choices) {
-  return {
-    kind: "select",
-    field: "SelectField",
-    input: "SelectInput",
-    choices
-  };
+	return {
+		kind: "select",
+		field: "SelectField",
+		input: "SelectInput",
+		choices
+	};
 }
-const toChoices = (ids) => ids.map((id) => ({ id, name: String(id) }));
+var toChoices = (ids) => ids.map((id) => ({
+	id,
+	name: String(id)
+}));
 function describeEnum({ entries = {} }) {
-  const ids = Object.keys(entries).filter((key) => typeof entries[entries[key]] !== "number").map((key) => entries[key]);
-  return select(toChoices(ids));
+	const ids = [];
+	for (const key of Object.keys(entries)) {
+		const value = entries[key];
+		if (value === void 0 || typeof entries[value] === "number") continue;
+		ids.push(value);
+	}
+	return select(toChoices(ids));
 }
 function describeUnion({ options = [] }) {
-  const ids = [];
-  for (const option of options) {
-    const { node: member } = unwrap(option);
-    const value = member.value;
-    if (member.type !== "literal" || typeof value !== "string" && typeof value !== "number") {
-      return unsupported("union schema");
-    }
-    ids.push(value);
-  }
-  return select(toChoices(ids));
+	const ids = [];
+	for (const option of options) {
+		const { node: member } = unwrap(option);
+		const value = member.value;
+		if (member.type !== "literal" || typeof value !== "string" && typeof value !== "number") return unsupported("union schema");
+		ids.push(value);
+	}
+	return select(toChoices(ids));
 }
 function describeArray({ element }) {
-  const member = element === void 0 ? void 0 : unwrap(element).node;
-  if (member?.type === "string") {
-    return {
-      kind: "textArray",
-      field: "TextArrayField",
-      input: "TextArrayInput"
-    };
-  }
-  if (member?.type === "object") return unsupported("array of objects");
-  return unsupported(`array of ${member?.type ?? "unknown"}s`);
+	const member = element === void 0 ? void 0 : unwrap(element).node;
+	if (member?.type === "string") return {
+		kind: "textArray",
+		field: "TextArrayField",
+		input: "TextArrayInput"
+	};
+	if (member?.type === "object") return unsupported("array of objects");
+	return unsupported(`array of ${member?.type ?? "unknown"}s`);
 }
 function describeKind(node) {
-  switch (node.type) {
-    case "string":
-      return describeString(node);
-    case "number":
-      return { kind: "number", field: "NumberField", input: "NumberInput" };
-    case "boolean":
-      return { kind: "boolean", field: "BooleanField", input: "BooleanInput" };
-    case "date":
-      return { kind: "date", field: "DateField", input: "DateInput" };
-    case "enum":
-      return describeEnum(node);
-    case "union":
-      return describeUnion(node);
-    case "array":
-      return describeArray(node);
-    default:
-      return unsupported(`${node.type || "unknown"} schema`);
-  }
+	switch (node.type) {
+		case "string": return describeString(node);
+		case "number": return {
+			kind: "number",
+			field: "NumberField",
+			input: "NumberInput"
+		};
+		case "boolean": return {
+			kind: "boolean",
+			field: "BooleanField",
+			input: "BooleanInput"
+		};
+		case "date": return {
+			kind: "date",
+			field: "DateField",
+			input: "DateInput"
+		};
+		case "enum": return describeEnum(node);
+		case "union": return describeUnion(node);
+		case "array": return describeArray(node);
+		default: return unsupported(`${node.type || "unknown"} schema`);
+	}
 }
+/** For core's block editor helpers; not exported from the package index. */
 function describeField(source, schema, references) {
-  const { node, label } = unwrap(schema);
-  const target = references && Object.hasOwn(references, source) ? references[source] : void 0;
-  const described = target === void 0 ? describeKind(node) : node.type === "array" ? {
-    kind: "referenceArray",
-    field: "ReferenceArrayField",
-    input: "ReferenceArrayInput",
-    reference: target
-  } : {
-    kind: "reference",
-    field: "ReferenceField",
-    input: "ReferenceInput",
-    reference: target
-  };
-  return {
-    source,
-    primary: source === "id",
-    ...label === void 0 ? {} : { label },
-    ...described
-  };
+	const { node, label } = unwrap(schema);
+	const target = references && Object.hasOwn(references, source) ? references[source] : void 0;
+	const described = target === void 0 ? describeKind(node) : node.type === "array" ? {
+		kind: "referenceArray",
+		field: "ReferenceArrayField",
+		input: "ReferenceArrayInput",
+		reference: target
+	} : {
+		kind: "reference",
+		field: "ReferenceField",
+		input: "ReferenceInput",
+		reference: target
+	};
+	return {
+		source,
+		primary: source === "id",
+		...label === void 0 ? {} : { label },
+		...described
+	};
 }
+/**
+* Turns a resource's registered Zod schema (Zod 3 or Zod 4) into one descriptor per field, in
+* schema key order. Returns `undefined` when there is no schema to read or it
+* is not an object. Both adapters' guessers build their views from this, never
+* from fetched values.
+*/
 function describeResource(resource, config) {
-  if (!config?.schema) return void 0;
-  const { node } = unwrap(config.schema);
-  if (node.type !== "object" || !node.shape) return void 0;
-  const { shape } = node;
-  return {
-    resource,
-    fields: Object.keys(shape).map(
-      (source) => describeField(source, shape[source], config.references)
-    )
-  };
+	if (!config?.schema) return void 0;
+	const { node } = unwrap(config.schema);
+	if (node.type !== "object" || !node.shape) return void 0;
+	const { shape } = node;
+	return {
+		resource,
+		fields: Object.keys(shape).map((source) => describeField(source, shape[source], config.references))
+	};
 }
-export {
-  describeResource
-};
+export { describeField, describeResource };

package/dist/resource/get-at-path.js

@@ -1,16 +1,31 @@
-const PATH_SEGMENT = /\[([^\]]*)\]|[^.[\]]+/g;
+// src/resource/get-at-path.ts
+/**
+* The one path grammar chelone reads a record with. Dot members (`a.b`),
+* bracket indices (`a[0].b`) and numeric-dot indices (`a.0.b`) all resolve to
+* the same value, matching `lodash/get`'s relevant semantics.
+*
+* The core tree, calendar and client-list readers read through this, and so do
+* both adapters' `useFieldValue` and `useGetRecordRepresentation`: a `source`
+* written one way reads the same record everywhere, and one walker is left.
+*/
+/** Matches a `[index]` bracket group or a run of non-`.` / non-`[` characters. */
+var PATH_SEGMENT = /\[([^\]]*)\]|[^.[\]]+/g;
+/**
+* Read the value at `source` off `record`. An empty `source` returns the record
+* itself; a step that is null, undefined or a primitive returns `undefined`.
+*
+* An own key equal to the whole `source` wins before any split, as in
+* `lodash/get`: a record that literally holds a `"nested.level"` key — a
+* flattened filter payload, for instance — still reads.
+*/
 function getAtPath(record, source) {
-  if (source === "") return record;
-  if (record !== null && typeof record === "object" && Object.hasOwn(record, source)) {
-    return record[source];
-  }
-  let current = record;
-  for (const match of source.matchAll(PATH_SEGMENT)) {
-    if (current === null || typeof current !== "object") return void 0;
-    current = current[match[1] !== void 0 ? match[1] : match[0]];
-  }
-  return current;
+	if (source === "") return record;
+	if (record !== null && typeof record === "object" && Object.hasOwn(record, source)) return record[source];
+	let current = record;
+	for (const match of source.matchAll(PATH_SEGMENT)) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[match[1] !== void 0 ? match[1] : match[0]];
+	}
+	return current;
 }
-export {
-  getAtPath
-};
+export { getAtPath };

package/dist/resource/identifier.d.ts

@@ -1 +1,19 @@
 export type Identifier = string | number;
+/**
+ * True for the value a record id or foreign key holds: a `string` or a `number`.
+ * The check for a value read out of a record at a `source`, where the record's
+ * own type does not pin the field.
+ */
+export declare function isIdentifier(value: unknown): value is Identifier;
+/**
+ * True for an array whose every member is an {@link Identifier}: the shape a
+ * to-many foreign key holds on a record.
+ */
+export declare function isIdentifierArray(value: unknown): value is Identifier[];
+/**
+ * The ids a to-many foreign key holds. An array that is all ids is returned as
+ * it is; one with a member that is not an id keeps its id members, because a
+ * nullable `int[]` reads as nulls between real ids and dropping the whole array
+ * would hide records the record has. Anything that is not an array is no ids.
+ */
+export declare function identifiersOf(value: unknown): Identifier[];

package/dist/resource/identifier.js

@@ -0,0 +1,27 @@
+// src/resource/identifier.ts
+/**
+* True for the value a record id or foreign key holds: a `string` or a `number`.
+* The check for a value read out of a record at a `source`, where the record's
+* own type does not pin the field.
+*/
+function isIdentifier(value) {
+	return typeof value === "string" || typeof value === "number";
+}
+/**
+* True for an array whose every member is an {@link Identifier}: the shape a
+* to-many foreign key holds on a record.
+*/
+function isIdentifierArray(value) {
+	return Array.isArray(value) && value.every(isIdentifier);
+}
+/**
+* The ids a to-many foreign key holds. An array that is all ids is returned as
+* it is; one with a member that is not an id keeps its id members, because a
+* nullable `int[]` reads as nulls between real ids and dropping the whole array
+* would hide records the record has. Anything that is not an array is no ids.
+*/
+function identifiersOf(value) {
+	if (isIdentifierArray(value)) return value;
+	return Array.isArray(value) ? value.filter(isIdentifier) : [];
+}
+export { identifiersOf, isIdentifier, isIdentifierArray };

package/dist/resource/record.d.ts

@@ -7,3 +7,7 @@ export interface ResourceRecord<TId extends Identifier = Identifier> {
 export type LooseRecord = ResourceRecord & {
     [key: string]: unknown;
 };
+/** True for a value shaped like a record: a non-null, non-array object with an `id`. The check for a value that reaches a hook typed `unknown`. */
+export declare function isResourceRecord(value: unknown): value is ResourceRecord;
+/** True for a non-null, non-array object: the shape a record has once it reaches a data provider. */
+export declare function isLooseRecord<T extends ResourceRecord>(value: T): value is T & LooseRecord;

package/dist/resource/record.js

@@ -0,0 +1,10 @@
+// src/resource/record.ts
+/** True for a value shaped like a record: a non-null, non-array object with an `id`. The check for a value that reaches a hook typed `unknown`. */
+function isResourceRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "id" in value;
+}
+/** True for a non-null, non-array object: the shape a record has once it reaches a data provider. */
+function isLooseRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export { isLooseRecord, isResourceRecord };

package/dist/resource/register.d.ts

@@ -20,6 +20,13 @@ export interface Register {
 export type RegisteredResources = Register extends {
     resources: infer TResources extends ResourceMap;
 } ? TResources : ResourceMap;
+/**
+ * The registered permissions type, or `unknown` when nothing is registered.
+ * An app registers it with `interface Register { permissions: string[] }`.
+ */
+export type RegisteredPermissions = Register extends {
+    permissions: infer TPermissions;
+} ? TPermissions : unknown;
 /** The registered resource names, or `string` when nothing is registered. */
 export type RegisteredResourceName = keyof RegisteredResources & string;
 /** The record type of a registered resource, or {@link LooseRecord} when it has no schema. */