@plitzi/sdk-shared 0.37.8 → 0.37.10

package/dist/devTools/utils/PlitziConsole.mjs

@@ -12,6 +12,9 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 	listeningParams;
 	#e = [];
 	#t = !1;
+	#n = /* @__PURE__ */ new Set();
+	#r = [];
+	recentLimit = 200;
 	constructor(e, t = 100) {
 		this.callbackInternal = e, this.pendingLimit = t;
 	}
@@ -24,6 +27,12 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 			this.pendingLogs = [];
 		}
 	}
+	addListener(e, { replay: t = !1 } = {}) {
+		if (t) for (let t of this.#r) e(t);
+		return this.#n.add(e), () => {
+			this.#n.delete(e);
+		};
+	}
 	setCallbackAddProvider(e) {
 		this.callbackAddProvider = e;
 	}
@@ -33,9 +42,20 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 	flush(e = !1) {
 		this.logsListened = [], e && (this.pendingLogs = []);
 	}
-	#n(e, t, r, i) {
+	#i(e, t, r, i) {
 		if (!this.callbackInternal && !n()) return;
 		let a = this.getTime(!0);
+		if (n()) {
+			let n = {
+				logType: e,
+				category: t,
+				message: r,
+				params: i,
+				time: a
+			};
+			this.#r.push(n), this.#r.length > this.recentLimit && this.#r.shift();
+			for (let e of this.#n) e(n);
+		}
 		if (!this.callbackInternal) {
 			this.pendingLogs.push({
 				logType: e,
@@ -58,9 +78,9 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 			message: r,
 			params: i,
 			time: a
-		}), this.#r()), this.logsListened.length > this.logsListenedLimit && this.logsListened.shift();
+		}), this.#a()), this.logsListened.length > this.logsListenedLimit && this.logsListened.shift();
 	}
-	#r() {
+	#a() {
 		this.#t || (this.#t = !0, queueMicrotask(() => {
 			this.#t = !1;
 			let e = this.callbackInternal, t = this.#e;
@@ -78,16 +98,16 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 		return e ? t(n) : n;
 	}
 	info(e, t, n) {
-		this.#n("info", e, t, n);
+		this.#i("info", e, t, n);
 	}
 	warning(e, t, n) {
-		this.#n("warning", e, t, n);
+		this.#i("warning", e, t, n);
 	}
 	danger(e, t, n) {
-		this.#n("danger", e, t, n);
+		this.#i("danger", e, t, n);
 	}
 	success(e, t, n) {
-		this.#n("success", e, t, n);
+		this.#i("success", e, t, n);
 	}
 	begin(e) {
 		this.listening = !0, this.listeningParams = { category: e };

package/dist/elements/ComponentContext.mjs

@@ -1,5 +1,4 @@
-import { createContext as e } from "react";
-var t = e({});
-t.displayName = "ComponentContext";
+import { sharedContext as e } from "../helpers/sharedContext.mjs";
+var t = e("ComponentContext", {});
 //#endregion
 export { t as default };

package/dist/flags/flagsCookie.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The cookie a tester forces flags with — the `qa` layer, the strongest there is.
+ *
+ * A cookie and not web storage for the reason the theme is one: the server renders with it, so the page a tester
+ * forced a flag on arrives drawn that way instead of being swapped after hydration. Named with the port, like the
+ * debug preference, because a cookie's scope has none (see `debugCookieName`).
+ *
+ * It is a preference that only means something where debugging is authorized. Everywhere else both halves ignore it
+ * — a published site's visitors could otherwise turn on any feature that is still behind a flag.
+ */
+export declare const flagsCookieName: (host: string | undefined) => string;
+/**
+ * `newCheckout:1,legacyNav:0` — a flag name and its value, nothing else survives the parse. The cookie's format, and
+ * any other place flags are written as one line of text (an environment variable).
+ */
+export declare const parseFlagList: (value: string | undefined) => Record<string, boolean>;
+export declare const serializeFlagList: (forced: Record<string, boolean>) => string;
+/** What is forced once one flag is forced to `value` — or, with `undefined`, once it is no longer forced at all. */
+export declare const withForcedFlag: (forced: Record<string, boolean>, name: string, value: boolean | undefined) => Record<string, boolean>;
+/** The flags a tester forced, from a `Cookie` header or `document.cookie`. */
+export declare const forcedFlagsFromCookies: (cookies: string | undefined, host: string | undefined) => Record<string, boolean>;
+/**
+ * Keeps what a tester forced for the next page this browser asks for — every page of the site, so a forced feature is
+ * on wherever the tester goes, and the server draws it that way. Nothing forced removes the cookie.
+ */
+export declare const writeForcedFlags: (host: string, forced: Record<string, boolean>) => void;

package/dist/flags/flagsCookie.mjs

@@ -0,0 +1,20 @@
+import { cookieFromHeader as e } from "../helpers/cookies.mjs";
+import { isFlagName as t } from "./schemaFlag.mjs";
+//#region src/flags/flagsCookie.ts
+var n = (e) => {
+	let t = e?.split(":")[1];
+	return t ? `plitzi_flags_${t}` : "plitzi_flags";
+}, r = (e) => e ? Object.fromEntries(e.split(",").map((e) => e.split(":")).filter(([e, n]) => t(e) && (n === "1" || n === "0")).map(([e, t]) => [e, t === "1"])) : {}, i = (e) => Object.entries(e).filter(([e]) => t(e)).map(([e, t]) => `${e}:${t ? "1" : "0"}`).join(","), a = (e, t, n) => {
+	let { [t]: r, ...i } = e;
+	return n === void 0 ? i : {
+		...i,
+		[t]: n
+	};
+}, o = (t, i) => r(e(t, n(i))), s = (e, t) => {
+	let r = n(e), a = i(t);
+	try {
+		document.cookie = a ? `${r}=${encodeURIComponent(a)};path=/;SameSite=Lax` : `${r}=;path=/;max-age=0;SameSite=Lax`;
+	} catch {}
+};
+//#endregion
+export { n as flagsCookieName, o as forcedFlagsFromCookies, r as parseFlagList, i as serializeFlagList, a as withForcedFlag, s as writeForcedFlags };

package/dist/flags/index.d.ts

@@ -0,0 +1,3 @@
+export * from './schemaFlag';
+export * from './resolveFlags';
+export * from './flagsCookie';

package/dist/flags/index.mjs

@@ -0,0 +1,4 @@
+import { FLAG_GATE_PATTERN as e, FLAG_NAME_PATTERN as t, isFlagName as n, isSchemaFlag as r } from "./schemaFlag.mjs";
+import { flagsCookieName as i, forcedFlagsFromCookies as a, parseFlagList as o, serializeFlagList as s, withForcedFlag as c, writeForcedFlags as l } from "./flagsCookie.mjs";
+import { FLAG_LAYERS as u, flagUserFromSSR as d, flagValues as f, hasConditions as p, passesFlagGate as m, resolveFlags as h, undeclaredFlagOverrides as g } from "./resolveFlags.mjs";
+export { e as FLAG_GATE_PATTERN, u as FLAG_LAYERS, t as FLAG_NAME_PATTERN, d as flagUserFromSSR, f as flagValues, i as flagsCookieName, a as forcedFlagsFromCookies, p as hasConditions, n as isFlagName, r as isSchemaFlag, o as parseFlagList, m as passesFlagGate, h as resolveFlags, s as serializeFlagList, g as undeclaredFlagOverrides, c as withForcedFlag, l as writeForcedFlags };

package/dist/flags/resolveFlags.d.ts

@@ -0,0 +1,60 @@
+import { VariableScope } from '../dataSource/resolveVariables';
+import { RuleGroup } from '../helpers/ruleEvaluator';
+import { Schema, SSRUser } from '../types';
+/**
+ * Who decided a flag, weakest first: the space's own declaration, then the server rendering it, then the SDK
+ * embedding it, then a tester with the dev tools open. Each layer only ever answers for a flag the space declares.
+ */
+export declare const FLAG_LAYERS: readonly ["space", "server", "sdk", "qa"];
+export type FlagLayer = (typeof FLAG_LAYERS)[number];
+export type FlagOverrideLayer = Exclude<FlagLayer, 'space'>;
+/** What each layer above the space says, by flag name. A layer that says nothing about a flag leaves it alone. */
+export type FlagOverrides = Partial<Record<FlagOverrideLayer, Record<string, boolean>>>;
+/** The visitor, as a flag's rule sees them: never a token, never anything the rules have no business matching on. */
+export type FlagUser = {
+    authenticated: boolean;
+    email?: string;
+    username?: string;
+    roles?: string[];
+};
+/** The visitor a server resolved, as a flag's rule sees them — the same fields the browser's rules see. */
+export declare const flagUserFromSSR: (user: Pick<SSRUser, "email" | "username" | "roles"> | undefined) => FlagUser;
+/** What a flag's rules are matched against: everything a variable's are, and who is visiting. */
+export type FlagScope = VariableScope & {
+    user?: FlagUser;
+};
+/**
+ * One flag's answer, and where it came from: the layer that decided, and — when the space did — the index of the
+ * rule that matched, absent when it was the flag's own default. What the dev tools show beside the value.
+ */
+export type FlagResolution = {
+    value: boolean;
+    layer: FlagLayer;
+    rule?: number;
+};
+/**
+ * Whether a rule says anything at all. A rule just added in the builder has an empty group, and the evaluator reads
+ * an empty `and` as true — so an unfinished rule would turn the flag the moment it was added. It is skipped instead,
+ * and the linter says it is there.
+ */
+export declare const hasConditions: (when: unknown) => when is RuleGroup;
+/**
+ * Every flag the space declares, resolved for this render: `{ newCheckout: { value: true, layer: 'space', rule: 0 } }`.
+ *
+ * The space answers first — the first of a flag's rules that matches, or its default — and each layer above it may
+ * replace that answer, in order. An override for a flag the space does not declare is not an answer to anything and
+ * is dropped here; {@link undeclaredFlagOverrides} names those so whoever set one can be told.
+ */
+export declare const resolveFlags: (declared: Schema["flags"], scope?: FlagScope, overrides?: FlagOverrides) => Record<string, FlagResolution>;
+/** The answers alone, as the `flags` source publishes them: `{ newCheckout: true }`. */
+export declare const flagValues: (resolutions: Record<string, FlagResolution>) => Record<string, boolean>;
+/** Overrides naming a flag the space does not declare — each one a typo or a flag removed from the space. */
+export declare const undeclaredFlagOverrides: (declared: Schema["flags"], overrides: FlagOverrides) => {
+    layer: FlagOverrideLayer;
+    name: string;
+}[];
+/** Whether a flag gate lets its element exist, given the flags as they resolved. An undeclared flag resolves off. */
+export declare const passesFlagGate: (gate: {
+    name: string;
+    is: boolean;
+} | undefined, values: Record<string, boolean>) => boolean;

package/dist/flags/resolveFlags.mjs

@@ -0,0 +1,38 @@
+import { evaluateRuleGroup as e } from "../helpers/ruleEvaluator.mjs";
+//#region src/flags/resolveFlags.ts
+var t = [
+	"space",
+	"server",
+	"sdk",
+	"qa"
+], n = (e) => e ? {
+	authenticated: !0,
+	email: e.email,
+	username: e.username,
+	roles: e.roles
+} : { authenticated: !1 }, r = [
+	"server",
+	"sdk",
+	"qa"
+], i = (e) => typeof e == "object" && !!e && "rules" in e && Array.isArray(e.rules) && e.rules.some((e) => typeof e == "object" && !!e && !("enabled" in e && e.enabled === !1)), a = (t, n) => Array.isArray(t.rules) ? t.rules.findIndex((t) => i(t.when) && e(t.when, n)) : -1, o = (e, t) => {
+	let n = a(e, t);
+	return n === -1 ? {
+		value: e.value,
+		layer: "space"
+	} : {
+		value: e.rules[n].value,
+		layer: "space",
+		rule: n
+	};
+}, s = (e, t = {}, n = {}) => Object.fromEntries(Object.entries(e ?? {}).map(([e, i]) => [e, r.reduce((t, r) => {
+	let i = n[r]?.[e];
+	return typeof i == "boolean" ? {
+		value: i,
+		layer: r
+	} : t;
+}, o(i, t))])), c = (e) => Object.fromEntries(Object.entries(e).map(([e, { value: t }]) => [e, t])), l = (e, t) => r.flatMap((n) => Object.keys(t[n] ?? {}).filter((t) => !Object.hasOwn(e ?? {}, t)).map((e) => ({
+	layer: n,
+	name: e
+}))), u = (e, t) => !e || (t[e.name] ?? !1) === e.is;
+//#endregion
+export { t as FLAG_LAYERS, n as flagUserFromSSR, c as flagValues, i as hasConditions, u as passesFlagGate, s as resolveFlags, l as undeclaredFlagOverrides };

package/dist/flags/schemaFlag.d.ts

@@ -0,0 +1,11 @@
+import { SchemaFlag } from '../types';
+/** A flag name: what `{{ flags.<name> }}` reads, so it has to be a valid key in a template path. */
+export declare const FLAG_NAME_PATTERN: RegExp;
+/** A gate as authoring and MCP write it: `name` while the flag is on, `!name` while it is off. */
+export declare const FLAG_GATE_PATTERN: RegExp;
+export declare const isFlagName: (name: string) => boolean;
+/**
+ * Whether a value is a flag as the resolver reads it — what every writer checks before storing one: a mutation, the
+ * live channel, the linter. A rule's `when` has to be a group; whether it says anything is the linter's to warn about.
+ */
+export declare const isSchemaFlag: (value: unknown) => value is SchemaFlag;

package/dist/flags/schemaFlag.mjs

@@ -0,0 +1,9 @@
+import { isRecord as e } from "../helpers/isRecord.mjs";
+//#region src/flags/schemaFlag.ts
+var t = "[A-Za-z_][A-Za-z0-9_]*", n = RegExp(`^${t}$`), r = RegExp(`^!?${t}$`), i = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]), a = (e) => n.test(e) && !i.has(e), o = (t) => e(t) && typeof t.value == "boolean" && (t.description === void 0 || typeof t.description == "string") && Array.isArray(t.rules) && t.rules.every((t) => e(t) && typeof t.value == "boolean" && e(t.when));
+//#endregion
+export { r as FLAG_GATE_PATTERN, n as FLAG_NAME_PATTERN, a as isFlagName, o as isSchemaFlag };

package/dist/flags/useFlagResolution.d.ts

@@ -0,0 +1,13 @@
+import { AuthContextValue } from '../types';
+import { FlagResolution, FlagUser } from './resolveFlags';
+/** The visitor as a flag's rule sees them, from what auth knows. */
+export declare const flagUserFrom: ({ authenticated, user }: Partial<Pick<AuthContextValue, "authenticated" | "user">>) => FlagUser;
+/**
+ * Every declared flag, resolved for where this render is and who is looking.
+ *
+ * What the `flags` source every element reads is published from. The router cannot wait for that source — it decides
+ * whether the page is gated off before any child renders — so it calls `resolveFlags` itself, with the same inputs.
+ * Stable while nothing changed, so the source is not written again on every navigation.
+ */
+declare const useFlagResolution: (auth: Partial<Pick<AuthContextValue, "authenticated" | "user">>) => Record<string, FlagResolution>;
+export default useFlagResolution;

package/dist/flags/useFlagResolution.mjs

@@ -0,0 +1,43 @@
+import { resolveFlags as e } from "./resolveFlags.mjs";
+import t from "../hooks/useStableValue.mjs";
+import n from "../store/renderSettings.mjs";
+import { useCommonStore as r } from "../store/index.mjs";
+import { useMemo as i } from "react";
+//#region src/flags/useFlagResolution.ts
+var a = ({ authenticated: e, user: t }) => {
+	let n = t?.details, r = { authenticated: e === !0 };
+	return n ? {
+		...r,
+		email: n.email,
+		username: n.username,
+		roles: n.roles
+	} : r;
+}, o = (o) => {
+	let { environment: s } = n(), [[c, l, u, d, f]] = r([
+		"schema.flags",
+		"navigation.routeParams",
+		"navigation.queryParams",
+		"navigation.hostname",
+		"flags.overrides"
+	]), { authenticated: p, user: m } = o, h = i(() => a({
+		authenticated: p,
+		user: m
+	}), [p, m]);
+	return t(i(() => e(c, {
+		environment: s,
+		hostname: d,
+		routeParams: l,
+		queryParams: u,
+		user: h
+	}, f), [
+		c,
+		s,
+		d,
+		l,
+		u,
+		h,
+		f
+	]));
+};
+//#endregion
+export { o as default, a as flagUserFrom };

package/dist/helpers/eventTarget.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An event's target read as a DOM node. `instanceof Node` answers false for a target inside an iframe — each window has
+ * its own `Node` — and the builder listens on its canvas iframe's document, so these test the node's own type instead.
+ */
+export declare const isNodeTarget: (target: EventTarget | null) => target is Node;
+/** An event's target as the node it is, for `contains`; null when it is not a node (a window, an XHR). */
+export declare const nodeOf: (target: EventTarget | null) => Node | null;
+export declare const isElementTarget: (target: EventTarget | null) => target is Element;
+/** An event's target as the element it is, for `closest`; null when it is a text node or no node at all. */
+export declare const elementOf: (target: EventTarget | null) => Element | null;

package/dist/helpers/eventTarget.mjs

@@ -0,0 +1,4 @@
+//#region src/helpers/eventTarget.ts
+var e = (e) => e !== null && "nodeType" in e && typeof e.nodeType == "number", t = (t) => e(t) ? t : null, n = (t) => e(t) && t.nodeType === Node.ELEMENT_NODE, r = (e) => n(e) ? e : null;
+//#endregion
+export { r as elementOf, n as isElementTarget, e as isNodeTarget, t as nodeOf };

package/dist/helpers/images.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A remote picture resized by the server that renders the page — the one vocabulary both ends speak.
+ *
+ * The widths are a closed set rather than whatever a page asks for: each one is a file the server makes and keeps,
+ * so a free width would let anybody fill its disk one request at a time.
+ */
+/** Where a page server that resizes images answers. */
+export declare const IMAGE_PATH = "/_plitzi/img";
+/** Every width a picture is offered at, narrowest first. */
+export declare const IMAGE_WIDTHS: readonly [320, 480, 640, 768, 960, 1280, 1600, 1920];
+export type ImageWidth = (typeof IMAGE_WIDTHS)[number];
+export declare const isImageWidth: (width: number) => width is ImageWidth;
+/** A picture another site serves — the only kind there is anything to resize; a path of this site is served as it is. */
+export declare const isRemoteImage: (src: string) => boolean;
+/** The address of `src` at `width` on the endpoint. */
+export declare const imageUrl: (endpoint: string, src: string, width: ImageWidth) => string;
+/** Every width as a `srcset`, for the browser to pick the one its layout needs. */
+export declare const imageSrcSet: (endpoint: string, src: string) => string;

package/dist/helpers/images.mjs

@@ -0,0 +1,13 @@
+//#region src/helpers/images.ts
+var e = "/_plitzi/img", t = [
+	320,
+	480,
+	640,
+	768,
+	960,
+	1280,
+	1600,
+	1920
+], n = (e) => t.some((t) => t === e), r = (e) => /^https?:\/\//i.test(e), i = (e, t, n) => `${e}?url=${encodeURIComponent(t)}&w=${String(n)}`, a = (e, n) => t.map((t) => `${i(e, n, t)} ${String(t)}w`).join(", ");
+//#endregion
+export { e as IMAGE_PATH, t as IMAGE_WIDTHS, a as imageSrcSet, i as imageUrl, n as isImageWidth, r as isRemoteImage };

package/dist/helpers/index.d.ts

@@ -2,9 +2,12 @@ import { default as fetchManifest } from './fetchManifest';
 import { default as generateFacade } from './generateFacade';
 import { default as syntaxHighlight } from './syntaxHighlight';
 export * from './cookies';
+export * from './eventTarget';
 export * from './fetchManifest';
 export * from './formatDate';
+export * from './interval';
 export * from './isDate';
+export * from './isRecord';
 export * from './generateFacade';
 export * from './reducerOrigin';
 export * from './ruleEvaluator';

package/dist/helpers/index.mjs

@@ -1,18 +1,21 @@
-import { filters as e } from "./twigWrapper/filters/filters.mjs";
-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";
-export { o as MAX_PARAM_PASSES, D as ParamsFromURL, m as cookieFromHeader, 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, p as syntaxHighlight, l as templatePaths, u as templateRootNames, C as toUnixSeconds };
+import { isRecord as e } from "./isRecord.mjs";
+import { filters as t } from "./twigWrapper/filters/filters.mjs";
+import { processTwig as n, processTwigParam as r, processTwigValue as i } from "./twigWrapper/processTwig/processTwig.mjs";
+import { hasTemplateSyntax as a } from "./twigWrapper/tokens/hasTemplateSyntax.mjs";
+import { hasValidToken as o } from "./twigWrapper/tokens/hasValidToken.mjs";
+import { MAX_PARAM_PASSES as s, resolveStepParam as c } from "./twigWrapper/processTwig/resolveStepParam.mjs";
+import { inspectTemplate as l } from "./twigWrapper/inspectTemplate.mjs";
+import { templatePaths as u, templateRootNames as d } from "./twigWrapper/templateRoots.mjs";
+import f from "./fetchManifest.mjs";
+import p from "./generateFacade.mjs";
+import m from "./syntaxHighlight.mjs";
+import { cookieFromHeader as h, documentCookies as g } from "./cookies.mjs";
+import { elementOf as _, isElementTarget as v, isNodeTarget as y, nodeOf as b } from "./eventTarget.mjs";
+import { formatDate as x, formatDateUTC as S, formatFromNow as C, formatUTCToLocal as w, getDurationMs as T, isValidFormat as E, parseDate as D, toUnixSeconds as O } from "./formatDate.mjs";
+import { INTERVAL_TRIGGER as k, MIN_INTERVAL_MS as A, intervalOf as j } from "./interval.mjs";
+import { isDate as M } from "./isDate.mjs";
+import { isUserEdit as N } from "./reducerOrigin.mjs";
+import { evaluateRuleGroup as P } from "./ruleEvaluator.mjs";
+import { ParamsFromURL as F, delay as I, emptyObject as L, getDisplayName as R, getKeyDecoded as z, getPathsFromObeject as B, hexToRGB as V, isInViewport as H, makeId as U } from "./utils.mjs";
+import { disableReactDevTools as W } from "./security.mjs";
+export { k as INTERVAL_TRIGGER, s as MAX_PARAM_PASSES, A as MIN_INTERVAL_MS, F as ParamsFromURL, h as cookieFromHeader, I as delay, W as disableReactDevTools, g as documentCookies, _ as elementOf, L as emptyObject, P as evaluateRuleGroup, f as fetchManifest, t as filters, x as formatDate, S as formatDateUTC, C as formatFromNow, w as formatUTCToLocal, p as generateFacade, R as getDisplayName, T as getDurationMs, z as getKeyDecoded, B as getPathsFromObeject, a as hasTemplateSyntax, o as hasValidToken, V as hexToRGB, l as inspectTemplate, j as intervalOf, M as isDate, v as isElementTarget, H as isInViewport, y as isNodeTarget, e as isRecord, N as isUserEdit, E as isValidFormat, U as makeId, b as nodeOf, D as parseDate, n as processTwig, r as processTwigParam, i as processTwigValue, c as resolveStepParam, m as syntaxHighlight, u as templatePaths, d as templateRootNames, O as toUnixSeconds };

package/dist/helpers/interval.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Repeating a flow every so often — an autoplay, a clock, a poll of something on the page — with no plugin to write.
+ *
+ * The element listening, the interactions manager and authoring read this one module, so the trigger's name, its
+ * floor and what it carries cannot drift between them.
+ */
+/** The trigger a repeating flow starts on: fired once per tick of each interval its element's flows declare. */
+export declare const INTERVAL_TRIGGER = "onInterval";
+/** Below a quarter of a second, a flow that repeats is a busy loop that happens to wait. */
+export declare const MIN_INTERVAL_MS = 250;
+export type IntervalTriggerPayload = {
+    /** The interval that ticked, in milliseconds: the flows that run are the ones declared with it. */
+    interval: number;
+    /** How many times it has ticked since the element appeared — `{{ tick.count }}` with `named('tick', …)`. */
+    count: number;
+};
+/** An interval a flow declares, read as the trigger reads it: a whole number of milliseconds, at least the floor. */
+export declare const intervalOf: (value: unknown) => number | undefined;

package/dist/helpers/interval.mjs

@@ -0,0 +1,7 @@
+//#region src/helpers/interval.ts
+var e = "onInterval", t = 250, n = (e) => {
+	let t = typeof e == "string" && e.trim() !== "" ? Number(e) : e;
+	return typeof t == "number" && Number.isInteger(t) && t >= 250 ? t : void 0;
+};
+//#endregion
+export { e as INTERVAL_TRIGGER, t as MIN_INTERVAL_MS, n as intervalOf };

package/dist/helpers/isRecord.d.ts

@@ -0,0 +1,2 @@
+/** A plain object read off untyped data — JSON, a message, a document — and not an array, which is an object too. */
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/helpers/isRecord.mjs

@@ -0,0 +1,4 @@
+//#region src/helpers/isRecord.ts
+var e = (e) => typeof e == "object" && !!e && !Array.isArray(e);
+//#endregion
+export { e as isRecord };

package/dist/helpers/scroll.d.ts

@@ -0,0 +1,42 @@
+/**
+ * What the scroll steps and the `onScroll` trigger read and write, as plain arithmetic over a box's sizes — so the
+ * meaning of `'80%'` or `'end'` is decided once, and tested without a browser.
+ */
+/** A box that scrolls, measured: what `Element` has, and all these functions read. */
+export type ScrollBox = {
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+    scrollHeight: number;
+    clientWidth: number;
+    clientHeight: number;
+};
+/** What `onScroll` hands its flow: where the box is, and whether it is at either end of the way it scrolls. */
+export type ScrollTriggerPayload = {
+    x: number;
+    y: number;
+    atStart: boolean;
+    atEnd: boolean;
+};
+export declare const SCROLL_BEHAVIORS: readonly ["smooth", "auto"];
+export type ScrollStepBehavior = (typeof SCROLL_BEHAVIORS)[number];
+/** Where `scrollIntoView` lands an element, on each axis. */
+export declare const SCROLL_POSITIONS: readonly ["start", "center", "end", "nearest"];
+export type ScrollStepPosition = (typeof SCROLL_POSITIONS)[number];
+/**
+ * A distance to move: pixels (`240`, `'240'`, `'240px'`) or a share of what the box shows (`'80%'` of its width) —
+ * negative goes back. `undefined` for nothing to move, or for text that is not a length.
+ */
+export declare const scrollDistance: (value: unknown, visible: number) => number | undefined;
+/**
+ * A place to go to on one axis: `'start'`, `'end'`, pixels from the start, or a share of the whole way (`'50%'` is
+ * half-way). `undefined` leaves that axis where it is.
+ */
+export declare const scrollPosition: (value: unknown, scrollSize: number, clientSize: number) => number | undefined;
+/**
+ * Where a box is, for `onScroll`. The ends are those of the way it scrolls — across for a row wider than its box,
+ * down otherwise — which is what an arrow that hides at the end of a carousel asks.
+ */
+export declare const scrollState: (box: ScrollBox) => ScrollTriggerPayload;
+/** The trigger a scroll fires, its action name in a flow. */
+export declare const SCROLL_TRIGGER = "onScroll";

package/dist/helpers/scroll.mjs

@@ -0,0 +1,30 @@
+//#region src/helpers/scroll.ts
+var e = ["smooth", "auto"], t = [
+	"start",
+	"center",
+	"end",
+	"nearest"
+], n = 1, r = /^(-?\d+(?:\.\d+)?)(px|%)?$/, i = (e, t) => {
+	if (typeof e == "number") return Number.isFinite(e) ? e : void 0;
+	if (typeof e != "string") return;
+	let n = r.exec(e.trim());
+	if (!n) return;
+	let i = Number(n[1]);
+	return n[2] === "%" ? i / 100 * t : i;
+}, a = (e, t, n) => {
+	let r = Math.max(t - n, 0);
+	if (e === "start") return 0;
+	if (e === "end") return r;
+	let a = i(e, r);
+	return a === void 0 ? void 0 : Math.min(Math.max(a, 0), r);
+}, o = (e) => {
+	let t = e.scrollWidth - e.clientWidth > n, r = t ? e.scrollLeft : e.scrollTop, i = t ? e.scrollWidth - e.clientWidth : e.scrollHeight - e.clientHeight;
+	return {
+		x: Math.round(e.scrollLeft),
+		y: Math.round(e.scrollTop),
+		atStart: r <= n,
+		atEnd: r >= i - n
+	};
+}, s = "onScroll";
+//#endregion
+export { e as SCROLL_BEHAVIORS, t as SCROLL_POSITIONS, s as SCROLL_TRIGGER, i as scrollDistance, a as scrollPosition, o as scrollState };

package/dist/helpers/sharedContext.d.ts

@@ -0,0 +1,14 @@
+import { Context } from 'react';
+/**
+ * A React context every copy of the Plitzi runtime on a page agrees on.
+ *
+ * One page can hold more than one copy. The builder carries its own and renders a space's elements with it, while a
+ * remote plugin imports `@plitzi/plitzi-sdk` — the SDK's copy — through the page's import map; the builder embedded in
+ * Plitzi's own site is a third, the site's. A context made with `createContext` belongs to the copy that made it, so a
+ * plugin in the builder's canvas read none of the canvas's providers: it fell through to the site around the builder,
+ * took its element for the plugin's own, its live mode for the editor's and its store for the space's.
+ *
+ * Made once per page, under `name`, by whichever copy asks first, and handed to every other: a provider from any copy
+ * is then seen by a consumer from any copy, and the nearest one wins as it should.
+ */
+export declare const sharedContext: <T>(name: string, defaultValue: T) => Context<T>;

package/dist/helpers/sharedContext.mjs

@@ -0,0 +1,9 @@
+import { createContext as e } from "react";
+var t = Symbol.for("plitzi.sharedContexts.v1"), n = (e) => (e[t] ??= /* @__PURE__ */ new Map(), e[t]), r = (t, r) => {
+	let i = n(globalThis), a = i.get(t);
+	if (a) return a;
+	let o = e(r);
+	return o.displayName = t, i.set(t, o), o;
+};
+//#endregion
+export { r as sharedContext };

package/dist/helpers/twigWrapper/Evaluator/Evaluator.d.ts

@@ -1,4 +1,12 @@
 import { ASTNode, Expression } from '../AST';
+/**
+ * Which empty tokens a render hands back as their own text, for a later pass that knows more: none, every one, or
+ * every one but those reading a SETTLED source — one whose value is final when the render runs, so that nothing later
+ * will fill it in. A component's `props` is one: every declared prop is in it, and an empty one is an answer.
+ */
+export type KeepEmptyTokens = boolean | {
+    settled: ReadonlySet<string>;
+};
 export type EvalResult = {
     readonly output: string;
     readonly variables: Record<string, unknown>;
@@ -12,6 +20,6 @@ export type EvalResult = {
  * that document, not text the reader has to give up on. A value printed anywhere else is printed as always: it IS the
  * JSON value there (`"seen": {{ count }}`).
  */
-export declare const evaluate: (nodes: readonly ASTNode[], context: Record<string, unknown>, keepEmptyTokens?: boolean, jsonStrings?: boolean) => EvalResult;
+export declare const evaluate: (nodes: readonly ASTNode[], context: Record<string, unknown>, keepEmptyTokens?: KeepEmptyTokens, jsonStrings?: boolean) => EvalResult;
 /** One expression's value, as it is — not rendered to text. What `processTwigValue` answers a `{{ expr }}` with. */
 export declare const evaluateExpression: (expression: Expression, context: Record<string, unknown>) => unknown;