@chelone/core 0.6.0 → 0.7.0

package/dist/auth/access-control.js

@@ -1,27 +1,31 @@
+// src/auth/access-control.ts
 function matchesAction(granted, action) {
-  const list = Array.isArray(granted) ? granted : [granted];
-  return list.includes("*") || list.includes(action);
+	const list = Array.isArray(granted) ? granted : [granted];
+	return list.includes("*") || list.includes(action);
 }
 function matchesResource(granted, resource) {
-  if (granted === "*") return true;
-  if (granted.endsWith(".*")) return resource.startsWith(granted.slice(0, -1));
-  return granted === resource;
+	if (granted === "*") return true;
+	if (granted.endsWith(".*")) return resource.startsWith(granted.slice(0, -1));
+	return granted === resource;
 }
+/**
+* Deny-by-default permission matcher (OR across permissions). `TRecord` is fixed
+* by the permissions and the params together, so a grant's predicate and the
+* record it reads are the same type.
+*/
 function canAccessWithPermissions(permissions, params) {
-  return permissions.some((permission) => {
-    if (!matchesAction(permission.action, params.action)) return false;
-    if (!matchesResource(permission.resource, params.resource)) return false;
-    if (permission.record) {
-      if (params.record == null) return false;
-      try {
-        return permission.record(params.record);
-      } catch {
-        return false;
-      }
-    }
-    return true;
-  });
+	return permissions.some((permission) => {
+		if (!matchesAction(permission.action, params.action)) return false;
+		if (!matchesResource(permission.resource, params.resource)) return false;
+		if (permission.record) {
+			if (params.record == null) return false;
+			try {
+				return permission.record(params.record);
+			} catch {
+				return false;
+			}
+		}
+		return true;
+	});
 }
-export {
-  canAccessWithPermissions
-};
+export { canAccessWithPermissions };

package/dist/auth/auth-options.d.ts

@@ -1,19 +1,25 @@
+import { type SkipToken } from "@tanstack/query-core";
 import type { AuthProvider, CanAccessParams, UserIdentity } from "./types.js";
-/** Plain option objects, same convention as the data factories (P2). */
-export declare function identityQueryOptions(authProvider: AuthProvider): {
-    queryKey: readonly ["auth", "getIdentity"];
-    queryFn: () => Promise<UserIdentity>;
-};
-export declare function canAccessQueryOptions(authProvider: AuthProvider, params: CanAccessParams): {
-    queryKey: readonly ["auth", "canAccess", CanAccessParams];
+/** The option shape of the factories that skip with no provider. */
+interface SkippableQueryOptions<TKey, TData> {
+    queryKey: TKey;
+    queryFn: SkipToken | (() => Promise<TData>);
+}
+/** What `getPermissions` takes: the key slot of {@link permissionsQueryOptions}. */
+type PermissionsParams = Parameters<NonNullable<AuthProvider["getPermissions"]>>[0];
+/**
+ * Plain option objects, same convention as the data factories (P2). With no
+ * provider, `identityQueryOptions`, `authStateQueryOptions` and
+ * `permissionsQueryOptions` set `queryFn: skipToken`, so the query never runs.
+ */
+export declare function identityQueryOptions(authProvider: AuthProvider | undefined): SkippableQueryOptions<readonly ["auth", "getIdentity"], UserIdentity>;
+export declare function canAccessQueryOptions(authProvider: AuthProvider | undefined, params: CanAccessParams): {
+    queryKey: readonly ["auth", "canAccess", CanAccessParams<import("../index.js").ResourceRecord<import("../index.js").Identifier>>];
     queryFn: () => Promise<boolean>;
 };
-export declare function authStateQueryOptions(authProvider: AuthProvider): {
-    queryKey: readonly ["auth", "checkAuth"];
-    queryFn: () => Promise<{
-        authenticated: boolean;
-    }>;
-};
+export declare function authStateQueryOptions(authProvider: AuthProvider | undefined): SkippableQueryOptions<readonly ["auth", "checkAuth"], {
+    authenticated: boolean;
+}>;
 /**
  * Fetch the current user permissions via `authProvider.getPermissions`.
  * No `getPermissions` on the provider = permissions not configured =
@@ -22,10 +28,7 @@ export declare function authStateQueryOptions(authProvider: AuthProvider): {
  * a queryFn resolving `undefined`. Mirrors {@link canAccessQueryOptions}: keyed
  * by the passed `params` so distinct param objects cache independently.
  */
-export declare function permissionsQueryOptions(authProvider: AuthProvider, params?: unknown): {
-    queryKey: readonly ["auth", "getPermissions", unknown];
-    queryFn: () => Promise<unknown>;
-};
+export declare function permissionsQueryOptions<TPermissions>(authProvider: AuthProvider<TPermissions> | undefined, params?: unknown): SkippableQueryOptions<readonly ["auth", "getPermissions", PermissionsParams], TPermissions | null>;
 /**
  * The triage result of {@link checkError}. Vanilla (react/vue-free) so both
  * adapters share the reject-payload parsing before doing logout/notify/redirect.
@@ -55,3 +58,4 @@ export interface CheckErrorOutcome {
  *   redirect; only an auth rejection ever logs the user out.
  */
 export declare function checkError(authProvider: AuthProvider, error: unknown): Promise<CheckErrorOutcome>;
+export {};

package/dist/auth/auth-options.js

@@ -1,60 +1,92 @@
+import { isRecord } from "../guards.js";
+import { skipToken } from "@tanstack/query-core";
+// src/auth/auth-options.ts
+/** `skipToken` (the query never runs) with no provider, else `read` bound to it. */
+function queryFnFor(authProvider, read) {
+	return authProvider ? () => read(authProvider) : skipToken;
+}
+/**
+* Plain option objects, same convention as the data factories (P2). With no
+* provider, `identityQueryOptions`, `authStateQueryOptions` and
+* `permissionsQueryOptions` set `queryFn: skipToken`, so the query never runs.
+*/
 function identityQueryOptions(authProvider) {
-  return {
-    queryKey: ["auth", "getIdentity"],
-    queryFn: async () => {
-      if (!authProvider.getIdentity) {
-        throw new Error(
-          "identityQueryOptions: the authProvider does not implement getIdentity."
-        );
-      }
-      return authProvider.getIdentity();
-    }
-  };
+	return {
+		queryKey: ["auth", "getIdentity"],
+		queryFn: queryFnFor(authProvider, async (provider) => {
+			if (!provider.getIdentity) throw new Error("identityQueryOptions: the authProvider does not implement getIdentity.");
+			return provider.getIdentity();
+		})
+	};
 }
 function canAccessQueryOptions(authProvider, params) {
-  return {
-    queryKey: ["auth", "canAccess", params],
-    // No canAccess on the provider = access control not configured = allow.
-    queryFn: async () => authProvider.canAccess?.(params) ?? true
-  };
+	return {
+		queryKey: [
+			"auth",
+			"canAccess",
+			params
+		],
+		queryFn: async () => authProvider?.canAccess?.(params) ?? true
+	};
 }
 function authStateQueryOptions(authProvider) {
-  return {
-    queryKey: ["auth", "checkAuth"],
-    queryFn: async () => {
-      try {
-        await authProvider.checkAuth();
-        return { authenticated: true };
-      } catch {
-        return { authenticated: false };
-      }
-    }
-  };
+	return {
+		queryKey: ["auth", "checkAuth"],
+		queryFn: queryFnFor(authProvider, async (provider) => {
+			try {
+				await provider.checkAuth();
+				return { authenticated: true };
+			} catch {
+				return { authenticated: false };
+			}
+		})
+	};
 }
+/**
+* Fetch the current user permissions via `authProvider.getPermissions`.
+* No `getPermissions` on the provider = permissions not configured =
+* resolves `null` (undefined-tolerant; never rejects for that reason). `null`
+* rather than `undefined` is the sentinel because react-query/vue-query forbid
+* a queryFn resolving `undefined`. Mirrors {@link canAccessQueryOptions}: keyed
+* by the passed `params` so distinct param objects cache independently.
+*/
 function permissionsQueryOptions(authProvider, params) {
-  return {
-    queryKey: ["auth", "getPermissions", params],
-    queryFn: async () => await authProvider.getPermissions?.(params) ?? null
-  };
+	return {
+		queryKey: [
+			"auth",
+			"getPermissions",
+			params
+		],
+		queryFn: queryFnFor(authProvider, async (provider) => await provider.getPermissions?.(params) ?? null)
+	};
 }
 function readProp(source, key) {
-  return source != null && typeof source === "object" && key in source ? source[key] : void 0;
+	return isRecord(source) && key in source ? source[key] : void 0;
 }
+/**
+* Error-triage helper for the data error path. Fail-safe: runs
+* `authProvider.checkError(error)` and NEVER throws.
+*
+* - checkError RESOLVES -> ordinary data error -> `{ logout: false }`.
+* - checkError REJECTS   -> invalid session -> `{ logout: true, ... }` carrying
+*   `redirectTo` / `logoutUser` / `message` hints from the reject payload (or,
+*   for `redirectTo`, the original error). Adapters do the logout + notify +
+*   redirect; only an auth rejection ever logs the user out.
+*/
 async function checkError(authProvider, error) {
-  try {
-    await authProvider.checkError(error);
-    return { logout: false, logoutUser: false };
-  } catch (rejection) {
-    const logoutUser = readProp(rejection, "logoutUser") ?? true;
-    const redirectTo = readProp(rejection, "redirectTo") ?? readProp(error, "redirectTo");
-    const message = readProp(rejection, "message");
-    return { logout: true, logoutUser, redirectTo, message };
-  }
+	try {
+		await authProvider.checkError(error);
+		return {
+			logout: false,
+			logoutUser: false
+		};
+	} catch (rejection) {
+		return {
+			logout: true,
+			logoutUser: readProp(rejection, "logoutUser") ?? true,
+			redirectTo: readProp(rejection, "redirectTo") ?? readProp(error, "redirectTo"),
+			message: readProp(rejection, "message")
+		};
+	}
 }
-export {
-  authStateQueryOptions,
-  canAccessQueryOptions,
-  checkError,
-  identityQueryOptions,
-  permissionsQueryOptions
-};
+export { authStateQueryOptions, canAccessQueryOptions, checkError, identityQueryOptions, permissionsQueryOptions };

package/dist/auth/permission-matrix.d.ts

@@ -0,0 +1,12 @@
+import { type Permission } from "./access-control.js";
+/** Role id to that role's grants. */
+export type PermissionMatrixValue = Record<string, Permission[]>;
+/** What one cell of a role's row shows. `inherited` is read-only: a wildcard grants it. */
+export type PermissionCellState = "granted" | "inherited" | "denied";
+export declare function getPermissionCell(grants: Permission[], resource: string, action: string): PermissionCellState;
+/** Flip one cell. An inherited cell returns `value` itself, so a caller can skip `onChange`. */
+export declare function togglePermission(value: PermissionMatrixValue, role: string, resource: string, action: string): PermissionMatrixValue;
+/** Grant or remove every listed action on a resource at once, skipping inherited cells. */
+export declare function setPermissionRow(value: PermissionMatrixValue, role: string, resource: string, actions: string[], granted: boolean): PermissionMatrixValue;
+/** True when every action is granted or inherited: the All checkbox. */
+export declare function isPermissionRowGranted(grants: Permission[], resource: string, actions: string[]): boolean;

package/dist/auth/permission-matrix.js

@@ -0,0 +1,67 @@
+import { canAccessWithPermissions } from "./access-control.js";
+// src/auth/permission-matrix.ts
+function actionsOf(permission) {
+	return Array.isArray(permission.action) ? permission.action : [permission.action];
+}
+/** A grant a cell can edit: this exact resource, no record predicate. */
+function isEditable(permission, resource) {
+	return permission.resource === resource && permission.record === void 0;
+}
+function getPermissionCell(grants, resource, action) {
+	if (grants.some((grant) => isEditable(grant, resource) && actionsOf(grant).includes(action))) return "granted";
+	return canAccessWithPermissions(grants, {
+		resource,
+		action
+	}) ? "inherited" : "denied";
+}
+function addAction(grants, resource, action) {
+	const index = grants.findIndex((grant) => isEditable(grant, resource));
+	if (grants[index] === void 0) return [...grants, {
+		resource,
+		action: [action]
+	}];
+	return grants.map((grant, i) => i === index ? {
+		...grant,
+		action: [...actionsOf(grant), action]
+	} : grant);
+}
+function removeAction(grants, resource, action) {
+	return grants.flatMap((grant) => {
+		if (!isEditable(grant, resource) || !actionsOf(grant).includes(action)) return [grant];
+		const left = actionsOf(grant).filter((name) => name !== action);
+		return left.length === 0 ? [] : [{
+			...grant,
+			action: left
+		}];
+	});
+}
+function withGrants(value, role, grants) {
+	return {
+		...value,
+		[role]: grants
+	};
+}
+/** Flip one cell. An inherited cell returns `value` itself, so a caller can skip `onChange`. */
+function togglePermission(value, role, resource, action) {
+	const grants = value[role] ?? [];
+	const state = getPermissionCell(grants, resource, action);
+	if (state === "inherited") return value;
+	return withGrants(value, role, state === "denied" ? addAction(grants, resource, action) : removeAction(grants, resource, action));
+}
+/** Grant or remove every listed action on a resource at once, skipping inherited cells. */
+function setPermissionRow(value, role, resource, actions, granted) {
+	const grants = value[role] ?? [];
+	const next = actions.reduce((current, action) => {
+		const state = getPermissionCell(current, resource, action);
+		if (state === "inherited") return current;
+		if (granted && state === "denied") return addAction(current, resource, action);
+		if (!granted && state === "granted") return removeAction(current, resource, action);
+		return current;
+	}, grants);
+	return next === grants ? value : withGrants(value, role, next);
+}
+/** True when every action is granted or inherited: the All checkbox. */
+function isPermissionRowGranted(grants, resource, actions) {
+	return actions.every((action) => getPermissionCell(grants, resource, action) !== "denied");
+}
+export { getPermissionCell, isPermissionRowGranted, setPermissionRow, togglePermission };

package/dist/auth/types.d.ts

@@ -1,21 +1,30 @@
 import type { Identifier } from "../resource/identifier.js";
+import type { ResourceRecord } from "../resource/record.js";
+import type { RegisteredPermissions } from "../resource/register.js";
 export interface UserIdentity {
     id: Identifier;
     fullName?: string;
     avatar?: string;
     [key: string]: unknown;
 }
-export interface CanAccessParams {
+/**
+ * One access check. `TRecord` is the record shape the check carries. Left
+ * unannotated it is a plain {@link ResourceRecord}, which only exposes `id`: a
+ * provider that runs `Permission<Post>`-style grants declares its own record
+ * type on `canAccess`'s params, which the interface accepts, and can then hand
+ * its params straight to `canAccessWithPermissions`.
+ */
+export interface CanAccessParams<TRecord extends ResourceRecord = ResourceRecord> {
     action: string;
     resource: string;
-    record?: unknown;
+    record?: TRecord;
 }
 /**
  * The auth contract. All methods return promises; reject = not authenticated /
  * not permitted. `refreshAuth` is the token-refresh hook point (charter §11);
  * the P6 shell builds the no-flash SSR gate on `checkAuth`.
  */
-export interface AuthProvider {
+export interface AuthProvider<TPermissions = RegisteredPermissions> {
     login(params: Record<string, unknown>): Promise<void | {
         redirectTo?: string;
     }>;
@@ -23,7 +32,8 @@ export interface AuthProvider {
     checkAuth(params?: unknown): Promise<void>;
     checkError(error: unknown): Promise<void>;
     getIdentity?(): Promise<UserIdentity>;
-    getPermissions?(params?: unknown): Promise<unknown>;
+    /** Resolves `undefined` when there are no permissions to give, e.g. nobody is signed in. */
+    getPermissions?(params?: unknown): Promise<TPermissions | undefined>;
     canAccess?(params: CanAccessParams): Promise<boolean>;
     handleCallback?(): Promise<void | {
         redirectTo?: string;

package/dist/block-editor/block-document.d.ts

@@ -0,0 +1,60 @@
+import type { StandardSchemaV1 } from "@tanstack/form-core";
+import { type FieldDescriptor } from "../resource/describe-resource.js";
+export type Attrs = Record<string, unknown>;
+/** The shape of tiptap JSON, with no tiptap import. */
+export interface BlockDocNode {
+    type?: string;
+    attrs?: Attrs;
+    content?: BlockDocNode[];
+    marks?: {
+        type: string;
+        attrs?: Attrs;
+    }[];
+    text?: string;
+}
+type BlockSchema<A extends Attrs> = StandardSchemaV1<unknown, A>;
+/**
+ * One block a block editor can insert. `schema` is a Zod object (3 or 4) whose
+ * output is the block's attrs. Adapters extend this with their render types.
+ */
+export interface BlockSpec<A extends Attrs = Attrs> {
+    name: string;
+    label: string;
+    group: string;
+    keywords?: string[];
+    description?: string;
+    schema: BlockSchema<A>;
+    content?: string;
+    atom?: boolean;
+}
+export interface BlockRegistry<B extends BlockSpec = BlockSpec> {
+    get(name: string): B | undefined;
+    list(): B[];
+    names(): string[];
+    /** Group names in the order a block first names them. */
+    groups(): string[];
+}
+export declare const unknownBlockType = "unknownBlock";
+export declare function createBlockRegistry<B extends BlockSpec>(blocks: readonly B[]): BlockRegistry<B>;
+/** Each key's `safeParse(undefined)` result when it succeeds, else `null`. */
+export declare function getBlockDefaultAttrs<A extends Attrs>(schema: BlockSchema<A>): {
+    [K in keyof A]: A[K] | null;
+};
+/** One descriptor per attr, for an adapter to build the block's config form from. */
+export declare function describeBlockAttrs(schema: BlockSchema<Attrs>): FieldDescriptor[];
+export declare function matchBlocks<B extends BlockSpec>(blocks: readonly B[], query: string): B[];
+/**
+ * Wraps each node of an unknown type in an `unknownBlock`, so the editor keeps
+ * it. `canLoad` also catches what a type name cannot: an unknown mark, or an
+ * unknown node inside a paragraph. A top-level block it rejects is wrapped
+ * whole, from the document as stored.
+ */
+export declare function wrapUnknownBlocks(doc: BlockDocNode, known: ReadonlySet<string>, canLoad?: (block: BlockDocNode) => boolean): BlockDocNode;
+export declare function unwrapUnknownBlocks(doc: BlockDocNode): BlockDocNode;
+/** A stored value an editor can load: an object whose `type` is `"doc"`. */
+export declare const isBlockDoc: (value: unknown) => value is BlockDocNode;
+export declare const emptyBlockDocument: () => BlockDocNode;
+export declare function isEmptyBlockDocument(value: BlockDocNode | null | undefined): boolean;
+/** An embed URL for a YouTube or Vimeo link, built from the checked id alone. */
+export declare function toEmbedSrc(url: string): string | null;
+export {};

package/dist/block-editor/block-document.js

@@ -0,0 +1,143 @@
+import { columnLabelMatches } from "../controller/data-table-columns.js";
+import { describeField } from "../resource/describe-resource.js";
+// src/block-editor/block-document.ts
+var unknownBlockType = "unknownBlock";
+var builtInNodes = /* @__PURE__ */ new Set([
+	"doc",
+	"text",
+	"paragraph",
+	"heading",
+	"blockquote",
+	"bulletList",
+	"orderedList",
+	"listItem",
+	"codeBlock",
+	"horizontalRule",
+	"hardBreak",
+	unknownBlockType
+]);
+function createBlockRegistry(blocks) {
+	const byName = /* @__PURE__ */ new Map();
+	const groups = /* @__PURE__ */ new Set();
+	for (const block of blocks) {
+		if (builtInNodes.has(block.name)) throw new Error(`block-editor: "${block.name}" is a built-in node`);
+		if (byName.has(block.name)) throw new Error(`block-editor: duplicate block name "${block.name}"`);
+		byName.set(block.name, block);
+		groups.add(block.group);
+	}
+	return {
+		get: (name) => byName.get(name),
+		list: () => [...byName.values()],
+		names: () => [...byName.keys()],
+		groups: () => [...groups]
+	};
+}
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isParsable = (value) => isObject(value) && typeof value.safeParse === "function";
+/** Zod 3 and Zod 4 objects both expose `shape`. */
+function shapeOf(schema) {
+	const shape = isObject(schema) ? schema.shape : void 0;
+	if (!isObject(shape)) throw new Error("block schema must be a z.object");
+	return shape;
+}
+/** Each key's `safeParse(undefined)` result when it succeeds, else `null`. */
+function getBlockDefaultAttrs(schema) {
+	const shape = shapeOf(schema);
+	const defaults = {};
+	for (const key of Object.keys(shape)) {
+		const member = shape[key];
+		const result = isParsable(member) ? member.safeParse(void 0) : void 0;
+		defaults[key] = result?.success ? result.data : null;
+	}
+	return defaults;
+}
+/** One descriptor per attr, for an adapter to build the block's config form from. */
+function describeBlockAttrs(schema) {
+	const shape = shapeOf(schema);
+	return Object.keys(shape).map((key) => describeField(key, shape[key], void 0));
+}
+function matchBlocks(blocks, query) {
+	return blocks.filter((block) => columnLabelMatches(block.label, query) || (block.keywords ?? []).some((keyword) => columnLabelMatches(keyword, query)) || block.description !== void 0 && columnLabelMatches(block.description, query));
+}
+var transparentTypes = /* @__PURE__ */ new Set(["doc", "text"]);
+function mapChildren(node, visit) {
+	return node.content === void 0 ? node : {
+		...node,
+		content: node.content.map(visit)
+	};
+}
+/**
+* Wraps each node of an unknown type in an `unknownBlock`, so the editor keeps
+* it. `canLoad` also catches what a type name cannot: an unknown mark, or an
+* unknown node inside a paragraph. A top-level block it rejects is wrapped
+* whole, from the document as stored.
+*/
+function wrapUnknownBlocks(doc, known, canLoad) {
+	const wrapNode = (node) => {
+		if (node.type !== void 0 && (transparentTypes.has(node.type) || known.has(node.type))) return mapChildren(node, wrapNode);
+		return {
+			type: unknownBlockType,
+			attrs: { payload: node }
+		};
+	};
+	const wrapped = mapChildren(doc, wrapNode);
+	if (canLoad === void 0 || wrapped.content === void 0) return wrapped;
+	return {
+		...wrapped,
+		content: wrapped.content.map((block, index) => canLoad(block) ? block : {
+			type: unknownBlockType,
+			attrs: { payload: doc.content?.[index] ?? block }
+		})
+	};
+}
+var isDocNode = (value) => isObject(value);
+function unwrapUnknownBlocks(doc) {
+	const unwrapNode = (node) => {
+		const payload = node.attrs?.payload;
+		if (node.type === "unknownBlock" && isDocNode(payload)) return payload;
+		return mapChildren(node, unwrapNode);
+	};
+	return mapChildren(doc, unwrapNode);
+}
+/** A stored value an editor can load: an object whose `type` is `"doc"`. */
+var isBlockDoc = (value) => isObject(value) && value.type === "doc";
+var emptyBlockDocument = () => ({
+	type: "doc",
+	content: [{ type: "paragraph" }]
+});
+function isEmptyBlockDocument(value) {
+	if (value === null || value === void 0) return true;
+	return (value.content ?? []).every((node) => node.type === "paragraph" && (node.content === void 0 || node.content.length === 0));
+}
+var youTubeHosts = /* @__PURE__ */ new Set([
+	"youtube.com",
+	"www.youtube.com",
+	"m.youtube.com"
+]);
+var youTubeId = /^[A-Za-z0-9_-]{11}$/;
+var vimeoId = /^\d+$/;
+/** An embed URL for a YouTube or Vimeo link, built from the checked id alone. */
+function toEmbedSrc(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return null;
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
+	const { hostname, pathname } = parsed;
+	if (youTubeHosts.has(hostname) && pathname === "/watch") {
+		const id = parsed.searchParams.get("v");
+		return id !== null && youTubeId.test(id) ? `https://www.youtube-nocookie.com/embed/${id}` : null;
+	}
+	if (hostname === "youtu.be") {
+		const id = pathname.slice(1);
+		return youTubeId.test(id) ? `https://www.youtube-nocookie.com/embed/${id}` : null;
+	}
+	if (hostname === "vimeo.com" || hostname === "www.vimeo.com") {
+		const id = pathname.slice(1);
+		return vimeoId.test(id) ? `https://player.vimeo.com/video/${id}` : null;
+	}
+	return null;
+}
+export { createBlockRegistry, describeBlockAttrs, emptyBlockDocument, getBlockDefaultAttrs, isBlockDoc, isEmptyBlockDocument, matchBlocks, toEmbedSrc, unknownBlockType, unwrapUnknownBlocks, wrapUnknownBlocks };

package/dist/block-editor/data-blocks.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import type { Attrs, BlockSpec } from "./block-document.js";
+export declare const dataBlockNames: readonly ["referenceRecord", "recordList", "chart"];
+export type DataBlockName = (typeof dataBlockNames)[number];
+/** A data block spec. The keys are always `chelone.block_editor.<name>.label` and `.description`. */
+export interface DataBlockSpec<TName extends DataBlockName, A extends Attrs> extends BlockSpec<A> {
+    name: TName;
+    group: "data";
+    labelKey: `chelone.block_editor.${TName}.label`;
+    descriptionKey: `chelone.block_editor.${TName}.description`;
+    description: string;
+    keywords: string[];
+}
+declare const referenceRecordSchema: z.ZodObject<{
+    resource: z.ZodDefault<z.ZodString>;
+    id: z.ZodDefault<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        card: "card";
+        inline: "inline";
+    }>>;
+}, z.core.$strip>;
+declare const recordListSchema: z.ZodObject<{
+    resource: z.ZodDefault<z.ZodString>;
+    perPage: z.ZodDefault<z.ZodNumber>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const chartSchema: z.ZodObject<{
+    resource: z.ZodDefault<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<{
+        bar: "bar";
+        line: "line";
+        pie: "pie";
+    }>>;
+    category: z.ZodDefault<z.ZodString>;
+    value: z.ZodDefault<z.ZodString>;
+    aggregate: z.ZodDefault<z.ZodEnum<{
+        count: "count";
+        sum: "sum";
+        avg: "avg";
+    }>>;
+    perPage: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const referenceRecordBlockSpec: DataBlockSpec<"referenceRecord", z.output<typeof referenceRecordSchema>>;
+export declare const recordListBlockSpec: DataBlockSpec<"recordList", z.output<typeof recordListSchema>>;
+export declare const chartBlockSpec: DataBlockSpec<"chart", z.output<typeof chartSchema>>;
+/** The fields a data block shows: the given ones, else every key but `id`, cut to `limit`. */
+export declare function pickDataBlockFields(record: object, fields?: readonly string[], limit?: number): string[];
+export declare function formatDataBlockValue(value: unknown): string;
+export interface ChartAggregateOptions {
+    category: string;
+    value: string;
+    aggregate: "count" | "sum" | "avg";
+}
+export interface ChartAggregatePoint {
+    name: string;
+    value: number;
+}
+/** A record's own value for a key. A key the record does not own reads as absent. */
+export declare const readDataBlockValue: (row: object, key: string) => unknown;
+/** Group rows by `String(row[category])` in first-seen order and reduce `value` by the aggregate. */
+export declare function aggregateChartData(rows: readonly object[], { category, value, aggregate }: ChartAggregateOptions): ChartAggregatePoint[];
+export {};