@chelone/core 0.6.0 → 0.9.0

package/dist/block-editor/data-blocks.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+// src/block-editor/data-blocks.ts
+var dataBlockNames = [
+	"referenceRecord",
+	"recordList",
+	"chart"
+];
+var referenceRecordSchema = z.object({
+	resource: z.string().default(""),
+	id: z.union([z.string(), z.number()]).nullable().default(null),
+	fields: z.array(z.string()).optional(),
+	layout: z.enum(["card", "inline"]).default("card")
+});
+var recordListSchema = z.object({
+	resource: z.string().default(""),
+	perPage: z.number().int().min(1).max(50).default(5),
+	fields: z.array(z.string()).optional()
+});
+var chartSchema = z.object({
+	resource: z.string().default(""),
+	type: z.enum([
+		"bar",
+		"line",
+		"pie"
+	]).default("bar"),
+	category: z.string().default(""),
+	value: z.string().default(""),
+	aggregate: z.enum([
+		"count",
+		"sum",
+		"avg"
+	]).default("count"),
+	perPage: z.number().int().min(1).max(1e3).default(100)
+});
+var referenceRecordBlockSpec = {
+	name: "referenceRecord",
+	label: "Reference record",
+	labelKey: "chelone.block_editor.referenceRecord.label",
+	group: "data",
+	keywords: [
+		"record",
+		"relation",
+		"embed",
+		"reference"
+	],
+	description: "Embed a live record",
+	descriptionKey: "chelone.block_editor.referenceRecord.description",
+	schema: referenceRecordSchema
+};
+var recordListBlockSpec = {
+	name: "recordList",
+	label: "Record list",
+	labelKey: "chelone.block_editor.recordList.label",
+	group: "data",
+	keywords: [
+		"list",
+		"table",
+		"records",
+		"collection"
+	],
+	description: "Embed a live list from a resource",
+	descriptionKey: "chelone.block_editor.recordList.description",
+	schema: recordListSchema
+};
+var chartBlockSpec = {
+	name: "chart",
+	label: "Chart",
+	labelKey: "chelone.block_editor.chart.label",
+	group: "data",
+	keywords: [
+		"chart",
+		"graph",
+		"bar",
+		"line",
+		"pie",
+		"analytics"
+	],
+	description: "Aggregate a resource into a chart",
+	descriptionKey: "chelone.block_editor.chart.description",
+	schema: chartSchema
+};
+/** The fields a data block shows: the given ones, else every key but `id`, cut to `limit`. */
+function pickDataBlockFields(record, fields, limit) {
+	const picked = fields !== void 0 && fields.length > 0 ? [...fields] : Object.keys(record).filter((key) => key !== "id");
+	return limit === void 0 ? picked : picked.slice(0, limit);
+}
+function formatDataBlockValue(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value !== "object" && typeof value !== "function") return String(value);
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+/** A record's own value for a key. A key the record does not own reads as absent. */
+var readDataBlockValue = (row, key) => Object.getOwnPropertyDescriptor(row, key)?.value;
+/** Group rows by `String(row[category])` in first-seen order and reduce `value` by the aggregate. */
+function aggregateChartData(rows, { category, value, aggregate }) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const raw = readDataBlockValue(row, category);
+		const name = raw === null || raw === void 0 ? "" : String(raw);
+		const group = groups.get(name) ?? {
+			count: 0,
+			sum: 0
+		};
+		group.count += 1;
+		group.sum += Number(readDataBlockValue(row, value)) || 0;
+		groups.set(name, group);
+	}
+	return [...groups].map(([name, { count, sum }]) => ({
+		name,
+		value: aggregate === "count" ? count : aggregate === "sum" ? sum : sum / count
+	}));
+}
+export { aggregateChartData, chartBlockSpec, dataBlockNames, formatDataBlockValue, pickDataBlockFields, readDataBlockValue, recordListBlockSpec, referenceRecordBlockSpec };

package/dist/chart/chart-data.js

@@ -1,59 +1,61 @@
-const DEFAULT_CHART_COLORS = [
-  "var(--chart-1)",
-  "var(--chart-2)",
-  "var(--chart-3)",
-  "var(--chart-4)",
-  "var(--chart-5)"
+// src/chart/chart-data.ts
+/** Theme variables the registry ships, in series order. */
+var DEFAULT_CHART_COLORS = [
+	"var(--chart-1)",
+	"var(--chart-2)",
+	"var(--chart-3)",
+	"var(--chart-4)",
+	"var(--chart-5)"
 ];
-const FALLBACK_COLOR = "var(--chart-1)";
+var FALLBACK_COLOR = "var(--chart-1)";
 function chartColor(index, colors = DEFAULT_CHART_COLORS) {
-  const list = colors.length > 0 ? colors : DEFAULT_CHART_COLORS;
-  const length = list.length;
-  return list[(index % length + length) % length] ?? FALLBACK_COLOR;
+	const list = colors.length > 0 ? colors : DEFAULT_CHART_COLORS;
+	const length = list.length;
+	return list[(index % length + length) % length] ?? FALLBACK_COLOR;
 }
 function toFiniteNumber(value) {
-  if (typeof value === "number") return Number.isFinite(value) ? value : null;
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
 }
 function toCartesianRows(data, xField, yField) {
-  return data.map((row, index) => ({
-    index,
-    x: row[xField],
-    y: toFiniteNumber(row[yField])
-  }));
+	return data.map((row, index) => ({
+		index,
+		x: row[xField],
+		y: toFiniteNumber(row[yField])
+	}));
 }
 function hasChartValues(rows) {
-  return rows.some((row) => row.y !== null);
+	return rows.some((row) => row.y !== null);
 }
 function toLabel(value) {
-  return value === void 0 || value === null ? "" : String(value);
+	return value === void 0 || value === null ? "" : String(value);
 }
 function toDonutSlices(data, labelField, valueField) {
-  const kept = [];
-  for (const row of data) {
-    const value = toFiniteNumber(row[valueField]);
-    if (value !== null && value > 0) {
-      kept.push({ label: toLabel(row[labelField]), value });
-    }
-  }
-  const total = kept.reduce((sum, slice) => sum + slice.value, 0);
-  if (total <= 0) return [];
-  return kept.map((slice) => ({ ...slice, share: slice.value / total }));
+	const kept = [];
+	for (const row of data) {
+		const value = toFiniteNumber(row[valueField]);
+		if (value !== null && value > 0) kept.push({
+			label: toLabel(row[labelField]),
+			value
+		});
+	}
+	const total = kept.reduce((sum, slice) => sum + slice.value, 0);
+	if (total <= 0) return [];
+	return kept.map((slice) => ({
+		...slice,
+		share: slice.value / total
+	}));
 }
+/** `delta` is a ratio (0.05 is 5.0%). Direction follows the sign of `delta`, not of the rounded text. */
 function getMetricDelta(delta) {
-  if (delta === void 0 || !Number.isFinite(delta)) return null;
-  const direction = delta > 0 ? "up" : delta < 0 ? "down" : "flat";
-  return { direction, text: `${(delta * 100).toFixed(1)}%` };
+	if (delta === void 0 || !Number.isFinite(delta)) return null;
+	return {
+		direction: delta > 0 ? "up" : delta < 0 ? "down" : "flat",
+		text: `${(delta * 100).toFixed(1)}%`
+	};
 }
-export {
-  DEFAULT_CHART_COLORS,
-  chartColor,
-  getMetricDelta,
-  hasChartValues,
-  toCartesianRows,
-  toDonutSlices
-};
+export { DEFAULT_CHART_COLORS, chartColor, getMetricDelta, hasChartValues, toCartesianRows, toDonutSlices };

package/dist/command-menu/hotkey.js

@@ -1,60 +1,71 @@
+// src/command-menu/hotkey.ts
 function parseBinding(binding) {
-  const lower = binding.toLowerCase();
-  const plus = lower === "+" || lower.endsWith("++");
-  const parts = (plus ? lower.slice(0, -1) : lower).split("+");
-  const key = plus ? "+" : parts.pop() ?? "";
-  return {
-    key,
-    mod: parts.includes("mod"),
-    shift: parts.includes("shift"),
-    alt: parts.includes("alt")
-  };
+	const lower = binding.toLowerCase();
+	const plus = lower === "+" || lower.endsWith("++");
+	const parts = (plus ? lower.slice(0, -1) : lower).split("+");
+	return {
+		key: plus ? "+" : parts.pop() ?? "",
+		mod: parts.includes("mod"),
+		shift: parts.includes("shift"),
+		alt: parts.includes("alt")
+	};
 }
-const punctuationCodes = {
-  "/": "Slash",
-  ".": "Period",
-  ",": "Comma",
-  ";": "Semicolon",
-  "'": "Quote",
-  "[": "BracketLeft",
-  "]": "BracketRight",
-  "\\": "Backslash",
-  "-": "Minus",
-  "=": "Equal",
-  "`": "Backquote"
+var punctuationCodes = {
+	"/": "Slash",
+	".": "Period",
+	",": "Comma",
+	";": "Semicolon",
+	"'": "Quote",
+	"[": "BracketLeft",
+	"]": "BracketRight",
+	"\\": "Backslash",
+	"-": "Minus",
+	"=": "Equal",
+	"`": "Backquote"
 };
 function codeFor(key) {
-  if (/^[a-z]$/.test(key)) return `Key${key.toUpperCase()}`;
-  if (/^[0-9]$/.test(key)) return `Digit${key}`;
-  return punctuationCodes[key];
+	if (/^[a-z]$/.test(key)) return `Key${key.toUpperCase()}`;
+	if (/^[0-9]$/.test(key)) return `Digit${key}`;
+	return punctuationCodes[key];
 }
+/**
+* Option and Shift rewrite `event.key` ("÷" for Option+/, "!" for Shift+1), so
+* a chord with either falls back to the physical key, but only when `key` is
+* not already a letter or digit. On a Dvorak layout the physical K key types
+* "t": that stays a "t", so `mod+k` does not fire on it.
+*/
 function keyMatches(event, parsed, eventKey) {
-  if (eventKey === parsed.key) return true;
-  if (!(parsed.alt || parsed.shift) || !event.code) return false;
-  if (/^[a-z0-9]$/i.test(event.key)) return false;
-  return event.code === codeFor(parsed.key);
+	if (eventKey === parsed.key) return true;
+	if (!(parsed.alt || parsed.shift) || !event.code) return false;
+	if (/^[a-z0-9]$/i.test(event.key)) return false;
+	return event.code === codeFor(parsed.key);
 }
+/**
+* Reads bindings such as `"mod+k"`, `"mod+shift+p"`, `"alt+/"` and `"f1"`.
+* `mod` is Meta or Ctrl. Modifiers match exactly: a binding without `mod`
+* does not fire while Ctrl or Meta is down.
+*/
 function matchesHotkey(event, binding) {
-  const parsed = parseBinding(binding);
-  if (!keyMatches(event, parsed, event.key.toLowerCase())) return false;
-  const modDown = event.metaKey || event.ctrlKey;
-  return modDown === parsed.mod && event.shiftKey === parsed.shift && event.altKey === parsed.alt;
+	const parsed = parseBinding(binding);
+	if (!keyMatches(event, parsed, event.key.toLowerCase())) return false;
+	return (event.metaKey || event.ctrlKey) === parsed.mod && event.shiftKey === parsed.shift && event.altKey === parsed.alt;
 }
 function isTypingTarget(target) {
-  if (!target) return false;
-  if (target.isContentEditable) return true;
-  const tag = target.tagName?.toLowerCase();
-  return tag === "input" || tag === "textarea" || tag === "select";
+	if (!target) return false;
+	if (target.isContentEditable) return true;
+	const tag = target.tagName?.toLowerCase();
+	return tag === "input" || tag === "textarea" || tag === "select";
 }
+/**
+* `matchesHotkey` plus two guards: nothing fires during IME composition, and a
+* binding with neither `mod` nor `alt` is ignored while `target` is typing, so
+* `/` never opens the menu from a text field.
+*/
 function shouldHandleHotkey(event, binding, target) {
-  if (event.isComposing) return false;
-  if (!matchesHotkey(event, binding)) return false;
-  const { mod, alt } = parseBinding(binding);
-  if (!mod && !alt && isTypingTarget(target)) return false;
-  return true;
+	if (event.isComposing) return false;
+	if (!matchesHotkey(event, binding)) return false;
+	const { mod, alt } = parseBinding(binding);
+	if (!mod && !alt && isTypingTarget(target)) return false;
+	return true;
 }
-export {
-  isTypingTarget,
-  matchesHotkey,
-  shouldHandleHotkey
-};
+export { isTypingTarget, matchesHotkey, shouldHandleHotkey };

package/dist/command-menu/recents.d.ts

@@ -1,5 +1,9 @@
 /** Where the command menu keeps its recents in a `CheloneStore`. */
 export declare const recentsKey = "command-menu.recents";
+/** Most recents the command menu keeps when `recentsLimit` is not set. */
+export declare const DEFAULT_RECENTS_LIMIT = 10;
+/** Wait after the last keystroke, in milliseconds, when `searchDebounceMs` is not set. */
+export declare const DEFAULT_SEARCH_DEBOUNCE_MS = 250;
 /**
  * A page the user visited. It holds no `path`: the link is rebuilt from the
  * resource and id, so a basename change cannot strand a saved entry.

package/dist/command-menu/recents.js

@@ -1,15 +1,16 @@
-const recentsKey = "command-menu.recents";
+// src/command-menu/recents.ts
+/** Where the command menu keeps its recents in a `CheloneStore`. */
+var recentsKey = "command-menu.recents";
+/** Most recents the command menu keeps when `recentsLimit` is not set. */
+var DEFAULT_RECENTS_LIMIT = 10;
+/** Wait after the last keystroke, in milliseconds, when `searchDebounceMs` is not set. */
+var DEFAULT_SEARCH_DEBOUNCE_MS = 250;
 function sameEntry(a, b) {
-  return a.type === b.type && a.resource === b.resource && (a.id === void 0 ? void 0 : String(a.id)) === (b.id === void 0 ? void 0 : String(b.id));
+	return a.type === b.type && a.resource === b.resource && (a.id === void 0 ? void 0 : String(a.id)) === (b.id === void 0 ? void 0 : String(b.id));
 }
+/** Puts `entry` first, drops an earlier copy, and cuts to `limit`. */
 function rememberRecent(recents, entry, limit) {
-  if (limit < 1) return [];
-  return [entry, ...recents.filter((other) => !sameEntry(other, entry))].slice(
-    0,
-    limit
-  );
+	if (limit < 1) return [];
+	return [entry, ...recents.filter((other) => !sameEntry(other, entry))].slice(0, limit);
 }
-export {
-  recentsKey,
-  rememberRecent
-};
+export { DEFAULT_RECENTS_LIMIT, DEFAULT_SEARCH_DEBOUNCE_MS, recentsKey, rememberRecent };

package/dist/command-menu/registry.d.ts

@@ -3,7 +3,7 @@ import { type MicroStore } from "../store/micro-store.js";
  * An extra command in the menu. `label` and `icon` are generic so each adapter
  * uses its own types (a React node, a Vue component).
  */
-export interface CommandAction<TLabel = string, TIcon = unknown> {
+export interface CommandAction<TLabel, TIcon> {
     id: string;
     label: TLabel;
     icon?: TIcon;
@@ -15,7 +15,7 @@ export interface CommandAction<TLabel = string, TIcon = unknown> {
     when?: () => boolean;
     onSelect: () => void;
 }
-export interface CommandRegistry<TLabel = string, TIcon = unknown> {
+export interface CommandRegistry<TLabel, TIcon> {
     store: MicroStore<{
         commands: CommandAction<TLabel, TIcon>[];
     }>;
@@ -28,7 +28,11 @@ export interface CommandRegistry<TLabel = string, TIcon = unknown> {
     unregister(id: string): void;
 }
 export declare const defaultCommandGroup = "actions";
-export declare function createCommandRegistry<TLabel = string, TIcon = unknown>(): CommandRegistry<TLabel, TIcon>;
-export declare function getVisibleCommands<T extends Pick<CommandAction, "when">>(commands: readonly T[]): T[];
+export declare function createCommandRegistry<TLabel, TIcon>(): CommandRegistry<TLabel, TIcon>;
+export declare function getVisibleCommands<T extends {
+    when?: () => boolean;
+}>(commands: readonly T[]): T[];
 /** Groups in first-seen order. A missing `group` reads as `"actions"`. */
-export declare function groupCommands<T extends Pick<CommandAction, "group">>(commands: readonly T[]): [string, T[]][];
+export declare function groupCommands<T extends {
+    group?: string;
+}>(commands: readonly T[]): [string, T[]][];

package/dist/command-menu/registry.js

@@ -1,53 +1,43 @@
 import { createMicroStore } from "../store/micro-store.js";
-const defaultCommandGroup = "actions";
+// src/command-menu/registry.ts
+var defaultCommandGroup = "actions";
 function createCommandRegistry() {
-  const store = createMicroStore({
-    commands: []
-  });
-  const unregister = (id) => {
-    store.setState((prev) => ({
-      commands: prev.commands.filter((command) => command.id !== id)
-    }));
-  };
-  const register = (action) => {
-    store.setState((prev) => {
-      const exists = prev.commands.some((command) => command.id === action.id);
-      return {
-        commands: exists ? prev.commands.map(
-          (command) => command.id === action.id ? action : command
-        ) : [...prev.commands, action]
-      };
-    });
-    return () => {
-      store.setState((prev) => ({
-        commands: prev.commands.filter((command) => command !== action)
-      }));
-    };
-  };
-  return { store, register, unregister };
+	const store = createMicroStore({ commands: [] });
+	const unregister = (id) => {
+		store.setState((prev) => ({ commands: prev.commands.filter((command) => command.id !== id) }));
+	};
+	const register = (action) => {
+		store.setState((prev) => {
+			return { commands: prev.commands.some((command) => command.id === action.id) ? prev.commands.map((command) => command.id === action.id ? action : command) : [...prev.commands, action] };
+		});
+		return () => {
+			store.setState((prev) => ({ commands: prev.commands.filter((command) => command !== action) }));
+		};
+	};
+	return {
+		store,
+		register,
+		unregister
+	};
 }
 function getVisibleCommands(commands) {
-  return commands.filter((command) => {
-    try {
-      return command.when ? command.when() !== false : true;
-    } catch {
-      return false;
-    }
-  });
+	return commands.filter((command) => {
+		try {
+			return command.when ? command.when() !== false : true;
+		} catch {
+			return false;
+		}
+	});
 }
+/** Groups in first-seen order. A missing `group` reads as `"actions"`. */
 function groupCommands(commands) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const command of commands) {
-    const group = command.group ?? defaultCommandGroup;
-    const members = groups.get(group);
-    if (members) members.push(command);
-    else groups.set(group, [command]);
-  }
-  return [...groups];
+	const groups = /* @__PURE__ */ new Map();
+	for (const command of commands) {
+		const group = command.group ?? "actions";
+		const members = groups.get(group);
+		if (members) members.push(command);
+		else groups.set(group, [command]);
+	}
+	return [...groups];
 }
-export {
-  createCommandRegistry,
-  defaultCommandGroup,
-  getVisibleCommands,
-  groupCommands
-};
+export { createCommandRegistry, defaultCommandGroup, getVisibleCommands, groupCommands };

package/dist/controller/calendar-dates.d.ts

@@ -15,6 +15,18 @@ export declare function parseCalendarDate(value: unknown): Date | undefined;
 export declare function calendarRange(view: CalendarView, anchor: Date, weekStartsOn: CalendarWeekStart): CalendarRange;
 /** One local midnight per day: adding to the day of the month never skips or repeats a day when the clocks change. */
 export declare function calendarDays(range: CalendarRange): Date[];
+/** A selected day cell: the whole local day, as ISO strings. */
+export interface CalendarDaySlot {
+    startISO: string;
+    endISO: string;
+    allDay: true;
+}
+/**
+ * The slot a whole day is: its local midnight to its last millisecond, the same
+ * inclusive end {@link calendarRange} gives a range. A day carrying a time is
+ * read as its day, not that instant.
+ */
+export declare function calendarDaySlot(day: Date): CalendarDaySlot;
 export declare function shiftCalendarAnchor(view: CalendarView, anchor: Date, direction: 1 | -1): Date;
 export declare const calendarDayKey: (date: Date) => string;
 export interface CalendarLabels {