@chelone/core 0.6.0 → 0.9.0

package/dist/form/date-format.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pure date, date-time and time format and parse helpers shared by the React and
+ * Vue `<DateInput>`, `<DateTimeInput>` and `<TimeInput>`, so both adapters
+ * format and validate a value the same way.
+ */
+import type { DateInputValue } from "./input-values.js";
+/**
+ * Format a form value (string / ISO / `Date` / timestamp / "") to a bare
+ * "YYYY-MM-DD" string for `<input type="date">`. Returns `null` for nullish/empty.
+ */
+export declare function formatDate(value: DateInputValue): string | null;
+/** Whether a raw `<input type="date">` string is empty or a valid date. */
+export declare function isValidDate(raw: string): boolean;
+/**
+ * Format a form value (ISO string / `Date` / timestamp) to the local
+ * `datetime-local` display string. Empty → "" (keeps the input controlled).
+ */
+export declare function formatDateTime(value: DateInputValue): string;
+/**
+ * Parse a local `datetime-local` string back to an ISO 8601 string (browser
+ * timezone). Returns `null` for empty/unparseable so a required validator fires.
+ */
+export declare function parseDateTimeToISO(value: string): string | null;
+/** Whether a raw `datetime-local` string is empty or parses to a valid date. */
+export declare function isValidDateTime(raw: string): boolean;
+/**
+ * Format a form value (`Date` / "HH:mm" string) to the "HH:mm" display string.
+ * Empty → "" (keeps the input controlled).
+ */
+export declare function formatTime(value: DateInputValue): string;
+/**
+ * Parse a "HH:mm"/"HH:mm:ss" string to a `Date` (today at that local time), for
+ * dataProvider compatibility. Returns `null` for empty/unparseable so a required
+ * validator still fires.
+ */
+export declare function parseTimeToDate(value: string): Date | null;
+/** Whether a raw `<input type="time">` string is empty or a valid time. */
+export declare function isValidTime(raw: string): boolean;

package/dist/form/date-format.js

@@ -0,0 +1,89 @@
+// src/form/date-format.ts
+var leftPad2 = (value) => `00${value}`.slice(-2);
+var leftPad4 = (value) => `0000${value}`.slice(-4);
+var dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+/** Convert a `Date` to a local "YYYY-MM-DD" string, or "" for an invalid date. */
+function dateToYmd(value) {
+	if (!(value instanceof Date) || Number.isNaN(value.getDate())) return "";
+	return `${value.getFullYear().toString()}-${leftPad2(value.getMonth() + 1)}-${leftPad2(value.getDate())}`;
+}
+/**
+* Format a form value (string / ISO / `Date` / timestamp / "") to a bare
+* "YYYY-MM-DD" string for `<input type="date">`. Returns `null` for nullish/empty.
+*/
+function formatDate(value) {
+	if (value == null || value === "") return null;
+	if (value instanceof Date) return dateToYmd(value);
+	if (typeof value === "string" && dateRegex.test(value)) return value;
+	return dateToYmd(new Date(value));
+}
+/** Whether a raw `<input type="date">` string is empty or a valid date. */
+function isValidDate(raw) {
+	if (raw === "") return true;
+	return dateRegex.test(raw) && !Number.isNaN(new Date(raw).getTime());
+}
+var dateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/;
+/** Convert a `Date` to a local "yyyy-MM-ddThh:mm" string, or "" if invalid. */
+function dateToLocalDateTime(value) {
+	if (!(value instanceof Date) || Number.isNaN(value.getDate())) return "";
+	return `${leftPad4(value.getFullYear())}-${leftPad2(value.getMonth() + 1)}-${leftPad2(value.getDate())}T${leftPad2(value.getHours())}:${leftPad2(value.getMinutes())}`;
+}
+/**
+* Format a form value (ISO string / `Date` / timestamp) to the local
+* `datetime-local` display string. Empty → "" (keeps the input controlled).
+*/
+function formatDateTime(value) {
+	if (value == null || value === "") return "";
+	if (value instanceof Date) return dateToLocalDateTime(value);
+	if (typeof value === "string" && dateTimeRegex.test(value)) return value;
+	return dateToLocalDateTime(new Date(value));
+}
+/**
+* Parse a local `datetime-local` string back to an ISO 8601 string (browser
+* timezone). Returns `null` for empty/unparseable so a required validator fires.
+*/
+function parseDateTimeToISO(value) {
+	if (value === "") return null;
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+/** Whether a raw `datetime-local` string is empty or parses to a valid date. */
+function isValidDateTime(raw) {
+	if (raw === "") return true;
+	return !Number.isNaN(new Date(raw).getTime());
+}
+var timeRegex = /^\d{2}:\d{2}(:\d{2})?$/;
+/** Convert a `Date` to a local "HH:mm" string, or "" if invalid. */
+function dateToHm(value) {
+	if (!(value instanceof Date) || Number.isNaN(value.getDate())) return "";
+	return `${leftPad2(value.getHours())}:${leftPad2(value.getMinutes())}`;
+}
+/**
+* Format a form value (`Date` / "HH:mm" string) to the "HH:mm" display string.
+* Empty → "" (keeps the input controlled).
+*/
+function formatTime(value) {
+	if (value == null || value === "") return "";
+	if (value instanceof Date) return dateToHm(value);
+	if (typeof value === "string" && timeRegex.test(value)) return value;
+	return dateToHm(new Date(value));
+}
+/**
+* Parse a "HH:mm"/"HH:mm:ss" string to a `Date` (today at that local time), for
+* dataProvider compatibility. Returns `null` for empty/unparseable so a required
+* validator still fires.
+*/
+function parseTimeToDate(value) {
+	if (timeRegex.test(value)) {
+		const [hh = "0", mm = "0", ss = "0"] = value.split(":");
+		const d = /* @__PURE__ */ new Date();
+		d.setHours(Number.parseInt(hh, 10), Number.parseInt(mm, 10), Number.parseInt(ss, 10), 0);
+		return d;
+	}
+	return null;
+}
+/** Whether a raw `<input type="time">` string is empty or a valid time. */
+function isValidTime(raw) {
+	return raw === "" || timeRegex.test(raw);
+}
+export { formatDate, formatDateTime, formatTime, isValidDate, isValidDateTime, isValidTime, parseDateTimeToISO, parseTimeToDate };

package/dist/form/dirty-values.d.ts

@@ -9,6 +9,6 @@
  * `address.city` yields `address`. A field never touched, or only registered,
  * is left out.
  */
-export declare function getDirtyFormValues(values: Record<string, unknown>, fieldMeta: Record<string, {
+export declare function getDirtyFormValues<TValues extends object>(values: TValues, fieldMeta: Record<string, {
     isDirty: boolean;
-} | undefined>): Record<string, unknown>;
+} | undefined>): Partial<TValues>;

package/dist/form/dirty-values.js

@@ -1,13 +1,24 @@
-const topLevelName = (path) => path.split(/[.[]/, 1)[0] ?? path;
+// src/form/dirty-values.ts
+/**
+* Reads the touched fields off a form-core form, so both adapters report the
+* same diff. form-core has no `dirtyFields` twin: its `fieldMeta` is keyed by
+* leaf path and each entry carries a sticky `isDirty`.
+*/
+/** `address.city` and `tags[0]` both belong to the top-level field. */
+var topLevelName = (path) => path.split(/[.[]/, 1)[0] ?? path;
+/**
+* Returns `{ [topLevelName]: values[topLevelName] }` for every field path whose
+* meta is dirty. A dirty nested path yields the whole top-level value, so
+* `address.city` yields `address`. A field never touched, or only registered,
+* is left out.
+*/
 function getDirtyFormValues(values, fieldMeta) {
-  const dirty = {};
-  for (const [path, meta] of Object.entries(fieldMeta)) {
-    if (!meta?.isDirty) continue;
-    const name = topLevelName(path);
-    dirty[name] = values[name];
-  }
-  return dirty;
+	const dirty = {};
+	for (const [path, meta] of Object.entries(fieldMeta)) {
+		if (!meta?.isDirty) continue;
+		const name = topLevelName(path);
+		dirty[name] = values[name];
+	}
+	return dirty;
 }
-export {
-  getDirtyFormValues
-};
+export { getDirtyFormValues };

package/dist/form/duration.d.ts

@@ -0,0 +1,22 @@
+export interface ParsedDuration {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+/**
+ * Parses an ISO-8601 duration string (e.g. `PT2H30M`, `P1DT4H`) into a
+ * `ParsedDuration` object. Returns `null` for unparseable input.
+ */
+export declare function parseIsoDuration(s: string): ParsedDuration | null;
+/** Renders a `ParsedDuration` in compact human-readable form, e.g. `2h 30m`. */
+export declare function compactDuration(p: ParsedDuration): string;
+/**
+ * Renders a `ParsedDuration` in relative long-form, e.g. `2 hours 30 minutes`.
+ *
+ * Clean-room reimplementation of date-fns's `formatDuration` (the only shape
+ * `<DurationField displayFormat="relative">` needs), so chelone avoids a
+ * date-fns dependency for a single formatter. Emits English unit words with
+ * the usual singular/plural rule, space-joined in largest-to-smallest order.
+ */
+export declare function relativeDuration(p: ParsedDuration): string;

package/dist/form/duration.js

@@ -0,0 +1,49 @@
+// src/form/duration.ts
+var ISO_RE = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
+/**
+* Parses an ISO-8601 duration string (e.g. `PT2H30M`, `P1DT4H`) into a
+* `ParsedDuration` object. Returns `null` for unparseable input.
+*/
+function parseIsoDuration(s) {
+	const m = s.match(ISO_RE);
+	if (!m) return null;
+	const [, d, h, mn, sc] = m;
+	const out = {};
+	if (d) out.days = +d;
+	if (h) out.hours = +h;
+	if (mn) out.minutes = +mn;
+	if (sc) out.seconds = +sc;
+	return out;
+}
+/** Renders a `ParsedDuration` in compact human-readable form, e.g. `2h 30m`. */
+function compactDuration(p) {
+	const parts = [];
+	if (p.days) parts.push(`${p.days}d`);
+	if (p.hours) parts.push(`${p.hours}h`);
+	if (p.minutes) parts.push(`${p.minutes}m`);
+	if (p.seconds) parts.push(`${p.seconds}s`);
+	return parts.join(" ") || "0m";
+}
+/**
+* Renders a `ParsedDuration` in relative long-form, e.g. `2 hours 30 minutes`.
+*
+* Clean-room reimplementation of date-fns's `formatDuration` (the only shape
+* `<DurationField displayFormat="relative">` needs), so chelone avoids a
+* date-fns dependency for a single formatter. Emits English unit words with
+* the usual singular/plural rule, space-joined in largest-to-smallest order.
+*/
+function relativeDuration(p) {
+	const units = [
+		["days", "day"],
+		["hours", "hour"],
+		["minutes", "minute"],
+		["seconds", "second"]
+	];
+	const parts = [];
+	for (const [key, word] of units) {
+		const n = p[key];
+		if (n) parts.push(`${n} ${word}${n === 1 ? "" : "s"}`);
+	}
+	return parts.join(" ") || "0 seconds";
+}
+export { compactDuration, parseIsoDuration, relativeDuration };

package/dist/form/edit-create-form.d.ts

@@ -1,8 +1,9 @@
-import { type CreateController, type CreateControllerState, type EditController, type EditControllerState, type RecordControllerContext, type RedirectRequest, type SaveTransform } from "../controller/record-controllers.js";
+import { type CreateController, type CreateControllerState, type EditController, type EditControllerState, type RecordControllerContext, type RedirectRequest, type SaveOptions, type SaveTransform } from "../controller/record-controllers.js";
 import type { MutationMode } from "../data/mutation-options.js";
 import type { Identifier } from "../resource/identifier.js";
 import type { RecordOf, ResourceMap } from "../resource/registry.js";
 import { type CheloneFormApi, type CheloneFormState, type FormControllerOptions } from "./form-controller.js";
+import { type ResourceFormHandle } from "./form-handle.js";
 /**
  * What the composed form controllers need: the P4 record-controller services
  * plus (optionally) the resource registry — a resource's zod schema becomes
@@ -65,20 +66,26 @@ export interface CreateFormControllerState<TRecord> extends CreateControllerStat
  * unsubscribe releases both. `getSnapshot` composes the two reference-stable
  * sub-snapshots with identity caching (uSES-safe).
  */
-export interface EditFormController<TRecord> {
+export interface EditFormController<TRecord, TName extends string = string> {
     form: CheloneFormApi<Partial<TRecord>>;
+    /** The form as a handle tagged with the resource it edits. */
+    handle: ResourceFormHandle<TName, Partial<TRecord>>;
     /** The composed P4 edit controller — imperative `save` with call-time options lives here. */
     recordController: EditController<TRecord>;
-    submit(): Promise<void>;
+    /** Validates, persists, reconciles. `options` apply to this one save, as `recordController.save`'s do. */
+    submit(options?: SaveOptions<TRecord>): Promise<void>;
     subscribe(listener: () => void): () => void;
     getSnapshot(): EditFormControllerState<TRecord>;
     destroy(): void;
 }
-export interface CreateFormController<TRecord> {
+export interface CreateFormController<TRecord, TName extends string = string> {
     form: CheloneFormApi<Partial<TRecord>>;
+    /** The form as a handle tagged with the resource it creates. */
+    handle: ResourceFormHandle<TName, Partial<TRecord>>;
     /** The composed P4 create controller. */
     recordController: CreateController<TRecord>;
-    submit(): Promise<void>;
+    /** Validates, persists, reconciles. `options` apply to this one save, as `recordController.save`'s do. */
+    submit(options?: SaveOptions<TRecord>): Promise<void>;
     subscribe(listener: () => void): () => void;
     getSnapshot(): CreateFormControllerState<TRecord>;
     destroy(): void;