@plitzi/sdk-shared 0.37.1 → 0.37.3

package/dist/dataSource/getBindingsDetails.mjs

@@ -1,43 +1,45 @@
-import e from "./utility/index.mjs";
-import { camelCase as t, get as n, set as r } from "@plitzi/plitzi-ui/helpers/lodash";
-import { QueryBuilderEvaluator as i } from "@plitzi/plitzi-ui/QueryBuilder";
-import { produce as a } from "immer";
+import { isTrue as e } from "./utility/truthiness.mjs";
+import t from "./utility/index.mjs";
+import { checkboxParams as n } from "./utility/checkboxParams.mjs";
+import { camelCase as r, get as i, set as a } from "@plitzi/plitzi-ui/helpers/lodash";
+import { QueryBuilderEvaluator as o } from "@plitzi/plitzi-ui/QueryBuilder";
+import { produce as s } from "immer";
 //#region src/dataSource/getBindingsDetails.ts
-var o = (e, t, r, i, a) => {
-	let o = i === "initialState" ? `definition.${i}.${a}` : `${i}.${a}`;
+var c = (e, t, n, r, a) => {
+	let o = r === "initialState" ? `definition.${r}.${a}` : `${r}.${a}`;
 	return {
-		fromValue: t ? n(e, t, n(r, o)) : void 0,
-		toValue: n(r, o, t ? n(e, t) : void 0)
+		fromValue: t ? i(e, t, i(n, o)) : void 0,
+		toValue: i(n, o, t ? i(e, t) : void 0)
 	};
-}, s = (s, c, l = {}) => {
-	let { attributes: u, definition: d } = c, { bindings: f } = d;
-	return !f || typeof f == "object" && !Object.keys(f).length ? {
-		attributes: u,
+}, l = (l, u, d = {}) => {
+	let { attributes: f, definition: p } = u, { bindings: m } = p;
+	return !m || typeof m == "object" && !Object.keys(m).length ? {
+		attributes: f,
 		style: {},
-		definition: d
-	} : a({
-		attributes: u,
-		style: l,
-		definition: d
-	}, (a) => {
-		Object.keys(f).forEach((c) => {
-			f[c] && Array.isArray(f[c]) && f[c].length && f[c].forEach((l) => {
-				let { source: u, transformers: d, when: f, enabled: p = !0 } = l, { to: m } = l;
-				if (!m || f && !i(f, s, !1, !0) || !p) return;
-				c === "style" && (m = t(m));
-				let { fromValue: h, toValue: g } = o(s, u, a, c, m), _ = h;
-				d && Array.isArray(d) && d.length > 0 && d.forEach((t) => {
-					let { action: r, params: i, enabled: o = !0 } = t;
-					if (!o) return;
-					let c = n(e, `${r}.callback`);
-					typeof c == "function" && (_ = c(_, i, a, {
-						...s,
-						sourceTo: g
+		definition: p
+	} : s({
+		attributes: f,
+		style: d,
+		definition: p
+	}, (s) => {
+		Object.keys(m).forEach((u) => {
+			m[u] && Array.isArray(m[u]) && m[u].length && m[u].forEach((d) => {
+				let { source: f, transformers: p, when: m, enabled: h = !0 } = d, { to: g } = d;
+				if (!g || m && !o(m, l, !1, !0) || !h) return;
+				u === "style" && (g = r(g));
+				let { fromValue: _, toValue: v } = c(l, f, s, u, g), y = _;
+				p && Array.isArray(p) && p.length > 0 && p.forEach((e) => {
+					let { action: r, params: i, enabled: a = !0 } = e;
+					if (!a) return;
+					let o = t[r];
+					o && (y = o.callback(y, n(o, i) ?? {}, s, {
+						...l,
+						sourceTo: v
 					}));
-				}), (typeof _ == "boolean" || typeof _ == "number" || _) && (c === "initialState" ? r(a, `definition.${c}.${m}`, _) : r(a, `${c}.${m}`, _));
+				}), u === "initialState" && g === "visibility" && f && i(l, f) !== void 0 && (y = e(y)), (typeof y == "boolean" || typeof y == "number" || y) && (u === "initialState" ? a(s, `definition.${u}.${g}`, y) : a(s, `${u}.${g}`, y));
 			});
 		});
 	});
 };
 //#endregion
-export { s as default };
+export { l as default };

package/dist/dataSource/index.d.ts

@@ -1,5 +1,6 @@
 export * from './hooks';
 export * from './helpers';
+export { evaluateComputed, liveSources } from './computed';
 export { default as getBindingsDetails } from './getBindingsDetails';
 export { default as resolveVariables } from './resolveVariables';
 export type { VariableScope } from './resolveVariables';

package/dist/dataSource/index.mjs

@@ -1,6 +1,7 @@
-import e, { utilityOptions as t } from "./utility/index.mjs";
-import n from "./getBindingsDetails.mjs";
-import r from "./helpers/getSourceName.mjs";
-import i from "./hooks/useRegisterSource.mjs";
-import a from "./resolveVariables.mjs";
-export { n as getBindingsDetails, r as getSourceName, a as resolveVariables, i as useRegisterSource, e as utility, t as utilityOptions };
+import { evaluateComputed as e, liveSources as t } from "./computed.mjs";
+import n, { utilityOptions as r } from "./utility/index.mjs";
+import i from "./getBindingsDetails.mjs";
+import a from "./helpers/getSourceName.mjs";
+import o from "./hooks/useRegisterSource.mjs";
+import s from "./resolveVariables.mjs";
+export { e as evaluateComputed, i as getBindingsDetails, a as getSourceName, t as liveSources, s as resolveVariables, o as useRegisterSource, n as utility, r as utilityOptions };

package/dist/dataSource/utility/checkboxParams.d.ts

@@ -0,0 +1,11 @@
+import { DataSourceUtility, DataSourceUtilityParamsValue } from '../../types';
+/**
+ * A checkbox param as the boolean it means.
+ *
+ * A document stores what an editor or an author wrote, and a checkbox arrives both ways: `true` from the builder,
+ * `'true'` or `'false'` from anything that writes params as text — an authored space, an export, an agent. A callback
+ * reading `if (asAge)` takes `'false'` for yes, so `dateConverter({ asAge: 'false' })` printed "3 days ago" and
+ * `isUnix: 'false'` parsed an ISO date as a number and gave the raw string back. Normalised once here, before any
+ * callback runs, every utility reads a checkbox the same way.
+ */
+export declare const checkboxParams: <TParams>(utility: Pick<DataSourceUtility<unknown, unknown, TParams>, "params">, params: DataSourceUtilityParamsValue<TParams> | undefined) => DataSourceUtilityParamsValue<TParams> | undefined;

package/dist/dataSource/utility/checkboxParams.mjs

@@ -0,0 +1,12 @@
+//#region src/dataSource/utility/checkboxParams.ts
+var e = (e, t) => {
+	if (!t) return t;
+	let n = t;
+	for (let [r, i] of Object.entries(e.params)) {
+		let e = t[r];
+		e !== "true" && e !== "false" || (typeof i.type == "function" ? i.type(t) : i.type) !== "checkbox" || (n === t && (n = { ...t }), n[r] = e === "true");
+	}
+	return n;
+};
+//#endregion
+export { e as checkboxParams };

package/dist/dataSource/utility/not.mjs

@@ -1,15 +1,12 @@
+import { isTrue as e } from "./truthiness.mjs";
 //#region src/dataSource/utility/not.ts
-var e = /* @__PURE__ */ new Set([
-	"false",
-	"0",
-	""
-]), t = (t) => typeof t == "string" ? !e.has(t.trim().toLowerCase()) : Array.isArray(t) ? t.length > 0 : !!t, n = {
+var t = {
 	action: "not",
 	title: "Not",
 	type: "utility",
 	params: {},
 	preview: { content: "" },
-	callback: (e) => !t(e)
+	callback: (t) => !e(t)
 };
 //#endregion
-export { n as default };
+export { t as default };

package/dist/dataSource/utility/stringToArray.mjs

@@ -13,7 +13,7 @@ var e = {
 	},
 	callback: (e, t) => {
 		let { separator: n } = t;
-		return console.log(e, t), typeof e == "string" ? e.split(n).map((e) => e.trim()) : e;
+		return typeof e == "string" ? e.split(n).map((e) => e.trim()) : e;
 	}
 };
 //#endregion

package/dist/dataSource/utility/truthiness.d.ts

@@ -0,0 +1 @@
+export declare const isTrue: (value: unknown) => boolean;

package/dist/dataSource/utility/truthiness.mjs

@@ -0,0 +1,8 @@
+//#region src/dataSource/utility/truthiness.ts
+var e = /* @__PURE__ */ new Set([
+	"false",
+	"0",
+	""
+]), t = (t) => typeof t == "string" ? !e.has(t.trim().toLowerCase()) : Array.isArray(t) ? t.length > 0 : !!t;
+//#endregion
+export { t as isTrue };

package/dist/dataSource/utility/twigTemplate.d.ts

@@ -1,3 +1,4 @@
 import { DataSourceUtility } from '../../types';
-declare const twigTemplate: DataSourceUtility<string, string | object, string>;
+export type TwigTemplateReturnMode = 'text' | 'value';
+declare const twigTemplate: DataSourceUtility<unknown, unknown, string>;
 export default twigTemplate;

package/dist/dataSource/utility/twigTemplate.mjs

@@ -1,27 +1,39 @@
-import { processTwig as e } from "../../helpers/twigWrapper/processTwig/processTwig.mjs";
-var t = {
+import { processTwig as e, processTwigValue as t } from "../../helpers/twigWrapper/processTwig/processTwig.mjs";
+var n = {
 	action: "twigTemplate",
 	title: "Twig Template",
 	type: "utility",
-	params: { template: {
-		label: "Template",
-		defaultValue: "Tokens {{source}} from the value selected to bind previously, {{sourceTo}} is your original value, other tokens via autocomplete",
-		type: "codemirror-text"
-	} },
+	params: {
+		template: {
+			label: "Template",
+			defaultValue: "Tokens {{source}} from the value selected to bind previously, {{sourceTo}} is your original value, other tokens via autocomplete",
+			type: "codemirror-text"
+		},
+		returnMode: {
+			label: "Returns",
+			defaultValue: "text",
+			type: "select",
+			options: [{
+				label: "Text",
+				value: "text"
+			}, {
+				label: "Value (a single {{ expression }})",
+				value: "value"
+			}]
+		}
+	},
 	preview: { template: "" },
-	callback: (t, n, r, i = {}) => {
-		let { template: a } = n, o = t;
+	callback: (n, r, i, a = {}) => {
+		let { template: o, returnMode: s = "text" } = r, c = {
+			source: n,
+			...a
+		};
 		try {
-			let n = e(a, {
-				source: t,
-				...i
-			});
-			(typeof n == "string" || typeof n == "object" && n) && (o = n);
+			return s === "value" ? t(o, c) : e(o, c);
 		} catch {
-			o = t;
+			return n;
 		}
-		return o;
 	}
 };
 //#endregion
-export { t as default };
+export { n as default };

package/dist/devTools/utils/PlitziConsole.mjs

@@ -1,6 +1,5 @@
-import { formatDate as e } from "../../helpers/formatDate.mjs";
 //#region src/devTools/utils/PlitziConsole.ts
-var t = class {
+var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}:${e(t.getMinutes())}:${e(t.getSeconds())}.${e(t.getMilliseconds(), 3)}`, n = () => typeof window < "u", r = class {
 	callbackInternal;
 	callbackAddProvider;
 	callbackRemoveProvider;
@@ -34,30 +33,31 @@ var t = class {
 	flush(e = !1) {
 		this.logsListened = [], e && (this.pendingLogs = []);
 	}
-	#n(e, t, n, r) {
-		let i = this.getTime(!0);
+	#n(e, t, r, i) {
+		if (!this.callbackInternal && !n()) return;
+		let a = this.getTime(!0);
 		if (!this.callbackInternal) {
 			this.pendingLogs.push({
 				logType: e,
 				category: t,
-				message: n,
-				params: r,
-				time: i
+				message: r,
+				params: i,
+				time: a
 			}), this.pendingLogs.length > this.pendingLimit && this.pendingLogs.shift();
 			return;
 		}
 		this.listening ? this.logsListened.push({
 			logType: e,
 			category: t,
-			message: n,
-			params: r,
-			time: i
+			message: r,
+			params: i,
+			time: a
 		}) : (this.#e.push({
 			logType: e,
 			category: t,
-			message: n,
-			params: r,
-			time: i
+			message: r,
+			params: i,
+			time: a
 		}), this.#r()), this.logsListened.length > this.logsListenedLimit && this.logsListened.shift();
 	}
 	#r() {
@@ -73,9 +73,9 @@ var t = class {
 	removeProviderMethod(e) {
 		typeof this.callbackRemoveProvider == "function" && this.callbackRemoveProvider(e);
 	}
-	getTime(t = !1) {
+	getTime(e = !1) {
 		let n = /* @__PURE__ */ new Date();
-		return t ? e(n, "HH:mm:ss.SSS") : n;
+		return e ? t(n) : n;
 	}
 	info(e, t, n) {
 		this.#n("info", e, t, n);
@@ -95,16 +95,16 @@ var t = class {
 	end() {
 		this.listening = !1, this.listeningCategory && this.logsListened.length > 0 && this.callbackInternal?.("info", this.listeningCategory, `${this.logsListened.length} Log${this.logsListened.length === 1 ? "" : "s"}`, { logs: this.logsListened }), this.logsListened = [], this.listeningCategory = void 0;
 	}
-}, n = new t();
-function r(e = "store") {
-	return ({ path: t, prevValue: r, nextValue: i }) => {
-		n.info("store", e, {
+}, i = new r();
+function a(e = "store") {
+	return ({ path: t, prevValue: n, nextValue: r }) => {
+		i.info("store", e, {
 			storeName: e,
 			path: t,
-			prev: r,
-			next: i
+			prev: n,
+			next: r
 		});
 	};
 }
 //#endregion
-export { r as createStoreDevToolsLogger, t as default, n as pConsole };
+export { a as createStoreDevToolsLogger, r as default, i as pConsole };

package/dist/helpers/cookies.d.ts

@@ -0,0 +1,10 @@
+/**
+ * One cookie's value out of a `Cookie` header — or out of `document.cookie`, which is written the same way.
+ *
+ * One function for both halves of the SDK, because the cookies it reads this way are the ones a server reads to render
+ * what the browser is about to hydrate: two parsers are two chances to disagree about a value, and a disagreement there
+ * is a page thrown away and drawn again. Undecodable values answer `undefined`, like absent ones.
+ */
+export declare const cookieFromHeader: (header: string | undefined, name: string) => string | undefined;
+/** `document.cookie`, or nothing where there is no document or it may not be read (a sandboxed frame throws). */
+export declare const documentCookies: () => string | undefined;

package/dist/helpers/cookies.mjs

@@ -0,0 +1,19 @@
+//#region src/helpers/cookies.ts
+var e = (e, t) => {
+	if (e) for (let n of e.split(";")) {
+		let e = n.indexOf("=");
+		if (e > -1 && n.slice(0, e).trim() === t) try {
+			return decodeURIComponent(n.slice(e + 1).trim());
+		} catch {
+			return;
+		}
+	}
+}, t = () => {
+	try {
+		return typeof document > "u" ? void 0 : document.cookie;
+	} catch {
+		return;
+	}
+};
+//#endregion
+export { e as cookieFromHeader, t as documentCookies };

package/dist/helpers/fetchManifest.d.ts

@@ -1,2 +1,11 @@
+/**
+ * A plugin's `plugin-manifest.json`, or `undefined` when it cannot be had.
+ *
+ * Plugins live on hosts of their own — a CDN, a bucket, the builder's resources — so this is nearly always a
+ * cross-origin request, and it is kept a SIMPLE one: `Accept` says what is wanted, where the `Content-Type` this used to
+ * send (on a GET, with no body to describe) made the browser ask the host's permission first. A host that allows plain
+ * cross-origin reads — the usual CORS setting of a bucket — refused that preflight, and the element rendered "Not
+ * Found" with the manifest sitting right there.
+ */
 declare const fetchManifest: <T extends object>(manifestUrl: string) => Promise<T | undefined>;
 export default fetchManifest;

package/dist/helpers/fetchManifest.mjs

@@ -1,13 +1,10 @@
 //#region src/helpers/fetchManifest.ts
 var e = async (e) => {
-	let t;
 	try {
-		return t = await (await fetch(e, {
-			method: "GET",
-			headers: { "Content-Type": "application/json" }
-		})).json(), t;
+		let t = await fetch(e, { headers: { Accept: "application/json" } });
+		return t.ok ? await t.json() : void 0;
 	} catch {
-		return t;
+		return;
 	}
 };
 //#endregion

package/dist/helpers/formatDate.d.ts

@@ -25,7 +25,11 @@ export declare const parseDate: (date: string | number | Date) => Date;
  */
 export declare function formatDate(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
 export declare function formatDateUTC(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
-/** Formats a UTC timestamp/string to local timezone */
+/**
+ * Formats a UTC timestamp/string in the local timezone. A `Date` is an instant and `format` reads its local fields, so
+ * there is nothing to convert: moving it first is what printed the repeated hour at the end of daylight saving time an
+ * hour off.
+ */
 export declare function formatUTCToLocal(date?: string | number | Date, formatStr?: string, locale?: SupportedLocale): string;
 /**
  * Returns the difference between two dates in milliseconds
@@ -52,5 +56,3 @@ export declare function getDurationMs(start: string | number | Date, end: string
 export declare function formatFromNow(date?: string | number | Date, locale?: SupportedLocale, options?: FormatDistanceToNowOptions): string;
 export declare function isValidFormat(formatStr: string): boolean;
 export declare const toUnixSeconds: (input: string | number | Date) => string;
-/** Strictly validates whether a string matches a given date-fns format. */
-export declare function isDate(value: string, formatStr: string): boolean;

package/dist/helpers/formatDate.mjs

@@ -1,58 +1,56 @@
-import { differenceInMilliseconds as e, format as t, formatDistanceToNow as n, getTime as r, isValid as i, parse as a, parseISO as o } from "date-fns";
-import { enUS as s, es as c, pt as l } from "date-fns/locale";
-import { toZonedTime as u } from "date-fns-tz";
+import { differenceInMilliseconds as e } from "date-fns/differenceInMilliseconds";
+import { format as t } from "date-fns/format";
+import { formatDistanceToNow as n } from "date-fns/formatDistanceToNow";
+import { getTime as r } from "date-fns/getTime";
+import { enUS as i } from "date-fns/locale/en-US";
+import { es as a } from "date-fns/locale/es";
+import { pt as o } from "date-fns/locale/pt";
+import { parseISO as s } from "date-fns/parseISO";
 //#region src/helpers/formatDate.ts
-var d = {
-	en: s,
-	es: c,
-	pt: l
-}, f = (e) => {
+var c = {
+	en: i,
+	es: a,
+	pt: o
+}, l = (e) => {
 	let t;
-	return t = typeof e == "number" ? e < 0xe8d4a51000 ? /* @__PURE__ */ new Date(e * 1e3) : new Date(e) : typeof e == "string" ? o(e) : e, t;
+	return t = typeof e == "number" ? e < 0xe8d4a51000 ? /* @__PURE__ */ new Date(e * 1e3) : new Date(e) : typeof e == "string" ? s(e) : e, t;
 };
-function p(e, n = "dd MMMM, yyyy", r = "en") {
+function u(e, n = "dd MMMM, yyyy", r = "en") {
 	if (!e) return "";
-	let i = f(e);
-	return t(i, n, { locale: d[r] });
+	let i = l(e);
+	return t(i, n, { locale: c[r] });
 }
-function m(e, n = "dd MMMM, yyyy", r = "en") {
+var d = (e) => {
+	let t = new Date(e.getUTCFullYear(), e.getUTCMonth(), e.getUTCDate(), e.getUTCHours(), e.getUTCMinutes(), e.getUTCSeconds(), e.getUTCMilliseconds());
+	return t.setFullYear(e.getUTCFullYear()), t;
+};
+function f(e, n = "dd MMMM, yyyy", r = "en") {
 	if (!e) return "";
-	let i = f(e);
-	return t(u(i, "UTC"), n, { locale: d[r] });
+	let i = l(e);
+	return t(d(i), n, { locale: c[r] });
 }
-function h(e, n = "dd MMMM, yyyy HH:mm", r = "en") {
-	if (!e) return "";
-	let i = f(e), a = Intl.DateTimeFormat().resolvedOptions().timeZone, o = u(i, a);
-	return t(o, n, { locale: d[r] });
+function p(e, n = "dd MMMM, yyyy HH:mm", r = "en") {
+	return e ? t(l(e), n, { locale: c[r] }) : "";
 }
-function g(t, n) {
-	let r = f(t), i = f(n);
+function m(t, n) {
+	let r = l(t), i = l(n);
 	return e(i, r);
 }
-function _(e, t = "en", r) {
+function h(e, t = "en", r) {
 	if (!e) return "";
-	let i = f(e);
+	let i = l(e);
 	return isNaN(i.getTime()) ? "" : n(i, {
 		...r,
-		locale: d[t]
+		locale: c[t]
 	});
 }
-function v(e) {
+function g(e) {
 	try {
 		return t(/* @__PURE__ */ new Date(), e), !0;
 	} catch {
 		return !1;
 	}
 }
-var y = (e) => Math.floor(r(f(e)) / 1e3).toString();
-function b(e, n) {
-	if (typeof e != "string") return !1;
-	try {
-		let r = a(e, n, /* @__PURE__ */ new Date());
-		return i(r) ? t(r, n) === e : !1;
-	} catch {
-		return !1;
-	}
-}
+var _ = (e) => Math.floor(r(l(e)) / 1e3).toString();
 //#endregion
-export { p as formatDate, m as formatDateUTC, _ as formatFromNow, h as formatUTCToLocal, g as getDurationMs, b as isDate, v as isValidFormat, f as parseDate, y as toUnixSeconds };
+export { u as formatDate, f as formatDateUTC, h as formatFromNow, p as formatUTCToLocal, m as getDurationMs, g as isValidFormat, l as parseDate, _ as toUnixSeconds };

package/dist/helpers/index.d.ts

@@ -1,8 +1,10 @@
 import { default as fetchManifest } from './fetchManifest';
 import { default as generateFacade } from './generateFacade';
 import { default as syntaxHighlight } from './syntaxHighlight';
+export * from './cookies';
 export * from './fetchManifest';
 export * from './formatDate';
+export * from './isDate';
 export * from './generateFacade';
 export * from './reducerOrigin';
 export * from './ruleEvaluator';

package/dist/helpers/index.mjs

@@ -1,14 +1,19 @@
 import { filters as e } from "./twigWrapper/filters/filters.mjs";
-import { processTwig as t } from "./twigWrapper/processTwig/processTwig.mjs";
-import { hasValidToken as n } from "./twigWrapper/tokens/hasValidToken.mjs";
-import { templateRootNames as r } from "./twigWrapper/templateRoots.mjs";
-import i from "./fetchManifest.mjs";
-import a from "./generateFacade.mjs";
-import o from "./syntaxHighlight.mjs";
-import { formatDate as s, formatDateUTC as c, formatFromNow as l, formatUTCToLocal as u, getDurationMs as d, isDate as f, isValidFormat as p, parseDate as m, toUnixSeconds as h } from "./formatDate.mjs";
-import { isUserEdit as g } from "./reducerOrigin.mjs";
-import { evaluateRuleGroup as _ } from "./ruleEvaluator.mjs";
-import { ParamsFromURL as v, delay as y, emptyObject as b, getDisplayName as x, getKeyDecoded as S, getPathsFromObeject as C, hexToRGB as w, isInViewport as T, makeId as E } from "./utils.mjs";
-import { disableReactDevTools as D } from "./security.mjs";
-import { createStripTypenameLink as O, stripTypenameDeep as k } from "./stripTypename.mjs";
-export { v as ParamsFromURL, O as createStripTypenameLink, y as delay, D as disableReactDevTools, b as emptyObject, _ as evaluateRuleGroup, i as fetchManifest, e as filters, s as formatDate, c as formatDateUTC, l as formatFromNow, u as formatUTCToLocal, a as generateFacade, x as getDisplayName, d as getDurationMs, S as getKeyDecoded, C as getPathsFromObeject, n as hasValidToken, w as hexToRGB, f as isDate, T as isInViewport, g as isUserEdit, p as isValidFormat, E as makeId, m as parseDate, t as processTwig, k as stripTypenameDeep, o as syntaxHighlight, r as templateRootNames, h as toUnixSeconds };
+import { processTwig as t, processTwigParam as n, processTwigValue as r } from "./twigWrapper/processTwig/processTwig.mjs";
+import { hasTemplateSyntax as i } from "./twigWrapper/tokens/hasTemplateSyntax.mjs";
+import { hasValidToken as a } from "./twigWrapper/tokens/hasValidToken.mjs";
+import { MAX_PARAM_PASSES as o, resolveStepParam as s } from "./twigWrapper/processTwig/resolveStepParam.mjs";
+import { inspectTemplate as c } from "./twigWrapper/inspectTemplate.mjs";
+import { templatePaths as l, templateRootNames as u } from "./twigWrapper/templateRoots.mjs";
+import d from "./fetchManifest.mjs";
+import f from "./generateFacade.mjs";
+import p from "./syntaxHighlight.mjs";
+import { cookieFromHeader as m, documentCookies as h } from "./cookies.mjs";
+import { formatDate as g, formatDateUTC as _, formatFromNow as v, formatUTCToLocal as y, getDurationMs as b, isValidFormat as x, parseDate as S, toUnixSeconds as C } from "./formatDate.mjs";
+import { isDate as w } from "./isDate.mjs";
+import { isUserEdit as T } from "./reducerOrigin.mjs";
+import { evaluateRuleGroup as E } from "./ruleEvaluator.mjs";
+import { ParamsFromURL as D, delay as O, emptyObject as k, getDisplayName as A, getKeyDecoded as j, getPathsFromObeject as M, hexToRGB as N, isInViewport as P, makeId as F } from "./utils.mjs";
+import { disableReactDevTools as I } from "./security.mjs";
+import { createStripTypenameLink as L, stripTypenameDeep as R } from "./stripTypename.mjs";
+export { o as MAX_PARAM_PASSES, D as ParamsFromURL, m as cookieFromHeader, L as createStripTypenameLink, O as delay, I as disableReactDevTools, h as documentCookies, k as emptyObject, E as evaluateRuleGroup, d as fetchManifest, e as filters, g as formatDate, _ as formatDateUTC, v as formatFromNow, y as formatUTCToLocal, f as generateFacade, A as getDisplayName, b as getDurationMs, j as getKeyDecoded, M as getPathsFromObeject, i as hasTemplateSyntax, a as hasValidToken, N as hexToRGB, c as inspectTemplate, w as isDate, P as isInViewport, T as isUserEdit, x as isValidFormat, F as makeId, S as parseDate, t as processTwig, n as processTwigParam, r as processTwigValue, s as resolveStepParam, R as stripTypenameDeep, p as syntaxHighlight, l as templatePaths, u as templateRootNames, C as toUnixSeconds };

package/dist/helpers/isDate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A module of its own because `parse` is the heaviest thing in date-fns — it compiles every token parser the format
+ * language has, about 100 MB of memory on the way in — and nothing that formats a date should pay for it. Imported from
+ * `formatDate`, it was paid by every page server at start, for a function no renderer calls.
+ */
+/** Strictly validates whether a string matches a given date-fns format. */
+export declare function isDate(value: string, formatStr: string): boolean;

package/dist/helpers/isDate.mjs

@@ -0,0 +1,15 @@
+import { format as e } from "date-fns/format";
+import { isValid as t } from "date-fns/isValid";
+import { parse as n } from "date-fns/parse";
+//#region src/helpers/isDate.ts
+function r(r, i) {
+	if (typeof r != "string") return !1;
+	try {
+		let a = n(r, i, /* @__PURE__ */ new Date());
+		return t(a) ? e(a, i) === r : !1;
+	} catch {
+		return !1;
+	}
+}
+//#endregion
+export { r as isDate };

package/dist/helpers/keys.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Keyboard shortcuts, as a space writes them: `'f'`, `'shift+f'`, `'mod+k'`, `'escape'`, several at once with commas
+ * (`'plus, ='`).
+ *
+ * Both halves of matching live here — reading what an author wrote and reading what a key press was — so they meet
+ * in one canonical form: modifiers in a fixed order, then the key, lower case (`ctrl+shift+f`). Authoring reads the
+ * first half to refuse a shortcut that could never fire; the element listening reads both.
+ */
+/** The trigger a shortcut starts: fired once per key press, with every shortcut it matched. */
+export declare const KEY_TRIGGER = "onKey";
+export type KeyTriggerPayload = {
+    /** The key pressed, canonical — `shift+f`. */
+    key: string;
+    /** Each `keys` param, exactly as written, that the press matched: the flows that run are the ones written so. */
+    shortcuts: string[];
+};
+export type ParsedKeys = {
+    /** Each shortcut, canonical: `ctrl+alt+shift+meta+key`, with only the modifiers it uses. */
+    combos: string[];
+    /** Each part that is not a shortcut, with why — empty when all of it is. */
+    problems: string[];
+};
+/** Every shortcut in what an author wrote, canonical, and what in it is not one. */
+export declare const parseKeys: (spec: string, isMac?: boolean) => ParsedKeys;
+export type KeyPress = Pick<KeyboardEvent, 'key' | 'code' | 'ctrlKey' | 'altKey' | 'shiftKey' | 'metaKey'>;
+/**
+ * A key press, in the form {@link parseKeys} writes.
+ *
+ * Two keyboard facts decide it. Shift is part of a LETTER's shortcut (`shift+f`), but a symbol is typed with whatever
+ * it takes — `+` is Shift+= on one keyboard and a key of its own on another — so for a symbol Shift is not counted.
+ * And with Alt, Ctrl or ⌘ held, `key` can be another character altogether (Option+F is `ƒ` on a Mac): the physical
+ * letter or digit is read from `code` instead.
+ */
+export declare const keyPressCombo: (press: KeyPress) => string;
+/**
+ * Whether a press, made in a text field, is the field's own editing — so a shortcut must not take it.
+ *
+ * With ⌘, Ctrl or Alt held a press in a field is otherwise a shortcut's, which is what lets `mod+k` open a palette
+ * from a search box. But `mod+a` in a title field is "select this text", not "select everything on the board", and
+ * `alt+backspace` deletes a word: a shortcut that took those would break typing wherever the page has one.
+ */
+export declare const isFieldEditing: (combo: string) => boolean;