wizards 0.1.9

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/columns-format.d.ts

@@ -0,0 +1,5 @@
+import type { DateFormat, DurationFormat, NumberFormat, TableColumn } from "./columns.js";
+export declare function formatNumberCell(value: unknown, format: NumberFormat, locale?: string): string;
+export declare function formatDateCell(value: unknown, format: DateFormat, locale?: string): string;
+export declare function formatDurationCell(value: unknown, format: DurationFormat): string;
+export declare function formatTableCell(column: TableColumn, value: unknown, locale?: string): string;

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/columns-format.js

@@ -0,0 +1,132 @@
+const MS_HOUR = 3_600_000;
+const MS_MINUTE = 60_000;
+const MS_SECOND = 1000;
+function fractionDigits(format) {
+    if (format.fractionDigits !== undefined) {
+        return format.fractionDigits;
+    }
+    return format.style === "integer" ? 0 : 2;
+}
+export function formatNumberCell(value, format, locale = "en") {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return "";
+    }
+    const digits = fractionDigits(format);
+    const grouping = format.grouping !== false;
+    if (format.style === "percent") {
+        return new Intl.NumberFormat(locale, {
+            maximumFractionDigits: digits,
+            minimumFractionDigits: digits,
+            style: "percent",
+            useGrouping: grouping,
+        }).format(value);
+    }
+    if (format.style === "currency" && format.currency) {
+        return new Intl.NumberFormat(locale, {
+            currency: format.currency,
+            maximumFractionDigits: digits,
+            minimumFractionDigits: digits,
+            style: "currency",
+            useGrouping: grouping,
+        }).format(value);
+    }
+    return new Intl.NumberFormat(locale, {
+        maximumFractionDigits: digits,
+        minimumFractionDigits: digits,
+        useGrouping: grouping,
+    }).format(value);
+}
+export function formatDateCell(value, format, locale = "en") {
+    if (typeof value !== "string" || value.length === 0) {
+        return "";
+    }
+    if (format.kind === "time") {
+        return formatClock(value, format.timePrecision ?? "minutes");
+    }
+    if (format.dateStyle === "iso") {
+        return format.kind === "date" ? value.slice(0, 10) : value;
+    }
+    const date = format.kind === "date" ? new Date(`${value}T00:00:00`) : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return value;
+    }
+    const dateStyle = format.dateStyle ?? "medium";
+    if (format.kind === "date") {
+        return new Intl.DateTimeFormat(locale, { dateStyle }).format(date);
+    }
+    const timePrecision = format.timePrecision ?? "minutes";
+    return new Intl.DateTimeFormat(locale, {
+        dateStyle,
+        timeStyle: timePrecision === "hours" ? "short" : "medium",
+    }).format(date);
+}
+function formatClock(value, precision) {
+    const [hours = "0", minutes = "00", seconds = "00"] = value.split(":");
+    if (precision === "hours") {
+        return `${hours.padStart(2, "0")}:00`;
+    }
+    if (precision === "minutes") {
+        return `${hours.padStart(2, "0")}:${minutes.padStart(2, "0")}`;
+    }
+    return `${hours.padStart(2, "0")}:${minutes.padStart(2, "0")}:${seconds.padStart(2, "0")}`;
+}
+export function formatDurationCell(value, format) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return "";
+    }
+    const ms = Math.max(0, Math.round(value));
+    if (format.display === "iso") {
+        return toIsoDuration(ms);
+    }
+    if (format.display === "minutes") {
+        return `${Math.round(ms / MS_MINUTE)} min`;
+    }
+    if (format.display === "hours") {
+        return `${(ms / MS_HOUR).toFixed(2)} h`;
+    }
+    if (format.display === "decimal-hours") {
+        return (ms / MS_HOUR).toFixed(2);
+    }
+    const hours = Math.floor(ms / MS_HOUR);
+    const minutes = Math.floor((ms % MS_HOUR) / MS_MINUTE);
+    const seconds = Math.floor((ms % MS_MINUTE) / MS_SECOND);
+    return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+function toIsoDuration(ms) {
+    const hours = Math.floor(ms / MS_HOUR);
+    const minutes = Math.floor((ms % MS_HOUR) / MS_MINUTE);
+    const seconds = Math.floor((ms % MS_MINUTE) / MS_SECOND);
+    const dayPart = hours >= 24 ? `P${Math.floor(hours / 24)}D` : "P";
+    const h = hours % 24;
+    return `${dayPart}T${h}H${minutes}M${seconds}S`;
+}
+export function formatTableCell(column, value, locale = "en") {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    switch (column.type) {
+        case "number":
+            return formatNumberCell(value, column.format, locale);
+        case "date":
+            return formatDateCell(value, column.format, locale);
+        case "duration":
+            return formatDurationCell(value, column.format);
+        case "boolean":
+            return value === true ? "true" : value === false ? "false" : "";
+        case "select":
+            return formatSelectCell(column, value);
+        default:
+            return String(value);
+    }
+}
+function formatSelectCell(column, value) {
+    const ids = Array.isArray(value) ? value : [value];
+    const labels = column.format.options.reduce((acc, option) => {
+        acc[option.id] = option.label;
+        return acc;
+    }, {});
+    return ids
+        .filter((id) => typeof id === "string" && id.length > 0)
+        .map((id) => labels[id] ?? id)
+        .join(", ");
+}

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/columns-value.d.ts

@@ -0,0 +1,11 @@
+import { type TableColumn } from "./columns.js";
+export declare class TableColumnValueError extends Error {
+    readonly code = "invalid_table_value";
+    readonly columnId: string;
+    constructor(columnId: string, message: string);
+}
+export declare function parseTableColumns(input: unknown): TableColumn[];
+/** Turn a writer-facing cell into the stored JSON value for one column. */
+export declare function coerceColumnValue(column: TableColumn, value: unknown): unknown;
+export declare function coerceRowValues(columns: readonly TableColumn[], values: Record<string, unknown>): Record<string, unknown>;
+export declare function mergeRowValues(columns: readonly TableColumn[], current: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown>;

package/node_modules/@engenty-wizards/shared/dist/engenty/data-tables/columns-value.js

@@ -0,0 +1,209 @@
+import { tableColumnsSchema, textColumnStyle, } from "./columns.js";
+export class TableColumnValueError extends Error {
+    code = "invalid_table_value";
+    columnId;
+    constructor(columnId, message) {
+        super(message);
+        this.name = "TableColumnValueError";
+        this.columnId = columnId;
+    }
+}
+const MS = {
+    days: 86_400_000,
+    hours: 3_600_000,
+    milliseconds: 1,
+    minutes: 60_000,
+    seconds: 1000,
+};
+export function parseTableColumns(input) {
+    return tableColumnsSchema.parse(input);
+}
+function isBlank(value) {
+    return value === null || value === undefined || value === "";
+}
+function optionIds(format) {
+    return new Set(format.options.map((option) => option.id));
+}
+function coerceDurationMs(value, format) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value * MS[format.inputUnit];
+    }
+    if (typeof value === "object" && value !== null && "value" in value) {
+        const raw = value;
+        if (typeof raw.value === "number" && Number.isFinite(raw.value)) {
+            const unit = typeof raw.unit === "string" && raw.unit in MS
+                ? raw.unit
+                : format.inputUnit;
+            return raw.value * MS[unit];
+        }
+    }
+    if (typeof value === "string") {
+        const iso = parseIsoDurationMs(value.trim());
+        if (iso !== null) {
+            return iso;
+        }
+        const asNumber = Number(value);
+        if (Number.isFinite(asNumber)) {
+            return asNumber * MS[format.inputUnit];
+        }
+    }
+    throw new Error("duration must be a number in the column's input unit");
+}
+function parseIsoDurationMs(raw) {
+    const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/i.exec(raw);
+    if (!match) {
+        return null;
+    }
+    const days = Number(match[1] ?? 0);
+    const hours = Number(match[2] ?? 0);
+    const minutes = Number(match[3] ?? 0);
+    const seconds = Number(match[4] ?? 0);
+    if (days + hours + minutes + seconds === 0 && raw === "P") {
+        return null;
+    }
+    return (days * MS.days +
+        hours * MS.hours +
+        minutes * MS.minutes +
+        seconds * MS.seconds);
+}
+function pad(value, size = 2) {
+    return String(value).padStart(size, "0");
+}
+function coerceDate(value, format) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error("date must be a string");
+    }
+    const raw = String(value).trim();
+    if (format.kind === "date") {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+            throw new Error("date must be YYYY-MM-DD");
+        }
+        return raw;
+    }
+    if (format.kind === "datetime") {
+        const parsed = Date.parse(raw);
+        if (Number.isNaN(parsed)) {
+            throw new Error("datetime must be an ISO-8601 timestamp");
+        }
+        return new Date(parsed).toISOString();
+    }
+    const precision = format.timePrecision ?? "minutes";
+    const time = normalizeClockTime(raw, precision);
+    if (!time) {
+        throw new Error(precision === "hours"
+            ? "time must be an hour (0–23 or HH:00)"
+            : "time must be HH:mm");
+    }
+    return time;
+}
+function normalizeClockTime(raw, precision) {
+    const hourOnly = /^(\d{1,2})$/.exec(raw);
+    const hm = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/.exec(raw);
+    const match = hourOnly ?? hm;
+    if (!match) {
+        return null;
+    }
+    const hours = Number(match[1]);
+    const minutes = hourOnly ? 0 : Number(match[2] ?? 0);
+    const seconds = hourOnly ? 0 : Number(match[3] ?? 0);
+    if (hours < 0 || hours > 23 || minutes > 59 || seconds > 59) {
+        return null;
+    }
+    if (precision === "hours") {
+        return `${pad(hours)}:00`;
+    }
+    if (precision === "minutes") {
+        return `${pad(hours)}:${pad(minutes)}`;
+    }
+    return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`;
+}
+function coerceSelect(value, format) {
+    const allowed = optionIds(format);
+    const asList = format.multiple
+        ? Array.isArray(value)
+            ? value
+            : [value]
+        : [value];
+    const ids = asList.map((item) => {
+        if (typeof item !== "string" || item.trim() === "") {
+            throw new Error("select values must be non-empty strings");
+        }
+        const id = item.trim();
+        if (!(format.allowCustom || allowed.has(id))) {
+            throw new Error(`"${id}" is not an allowed value`);
+        }
+        return id;
+    });
+    return format.multiple ? ids : (ids[0] ?? "");
+}
+function coerceNumber(value, integer) {
+    const n = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(n)) {
+        throw new Error("number must be finite");
+    }
+    if (integer && !Number.isInteger(n)) {
+        throw new Error("this column only accepts whole numbers");
+    }
+    return n;
+}
+function coerceText(column, value) {
+    const text = String(value);
+    if (textColumnStyle(column) === "single") {
+        return text.replace(/[\r\n]+/g, " ");
+    }
+    return text;
+}
+/** Turn a writer-facing cell into the stored JSON value for one column. */
+export function coerceColumnValue(column, value) {
+    if (isBlank(value)) {
+        if (column.required) {
+            throw new TableColumnValueError(column.id, `"${column.name}" is required`);
+        }
+        return null;
+    }
+    try {
+        switch (column.type) {
+            case "text":
+                return coerceText(column, value);
+            case "boolean":
+                if (typeof value === "boolean") {
+                    return value;
+                }
+                if (value === "true" || value === "1") {
+                    return true;
+                }
+                if (value === "false" || value === "0") {
+                    return false;
+                }
+                throw new Error("boolean must be true or false");
+            case "number":
+                return coerceNumber(value, column.format.style === "integer");
+            case "date":
+                return coerceDate(value, column.format);
+            case "duration":
+                return coerceDurationMs(value, column.format);
+            case "select":
+                return coerceSelect(value, column.format);
+            default:
+                return value;
+        }
+    }
+    catch (error) {
+        throw new TableColumnValueError(column.id, error instanceof Error ? error.message : String(error));
+    }
+}
+export function coerceRowValues(columns, values) {
+    const known = new Set(columns.map((column) => column.id));
+    const extra = Object.keys(values).filter((key) => !known.has(key));
+    if (extra.length > 0) {
+        throw new TableColumnValueError(extra[0] ?? "", `unknown column "${extra[0]}"`);
+    }
+    const next = {};
+    for (const column of columns) {
+        next[column.id] = coerceColumnValue(column, values[column.id]);
+    }
+    return next;
+}
+export function mergeRowValues(columns, current, patch) {
+    return coerceRowValues(columns, { ...current, ...patch });
+}