@plitzi/sdk-shared 0.33.2 → 0.34.1

package/dist/authoring/builder.d.ts

@@ -0,0 +1,51 @@
+import { ParamSpec } from './paramSpec';
+import { InteractionCallback, InteractionCallbackContext, InteractionCallbackParam, InteractionCallbackPreviews, InteractionCallbackType } from '../types';
+export declare const toBuilderParams: (spec: ParamSpec) => Record<string, InteractionCallbackParam>;
+/** What a declared action carries, whichever kind of action it is. */
+export interface BuiltinActionSpec {
+    title: string;
+    /**
+     * What KIND of node this action produces, which is also how the runtime resolves it: a `globalCallback` is
+     * looked up under its source module, a `callback` under an element's id, a `utility` under nothing at all.
+     * A global callback is the common case and the default.
+     */
+    type?: InteractionCallbackType;
+    /** When true the param set is CLOSED: a key not listed is a mistake, dropped on apply and warned in validation. */
+    strictParams: boolean;
+    params: ParamSpec;
+    /** The shape of what the step puts in the flow scope, so a later step can be written against it. */
+    preview?: InteractionCallbackPreviews;
+}
+/**
+ * What a source declares about a `globalCallback` of its own.
+ *
+ * The `source` is the registration id the runtime looks the callback up under — the value a node's `elementId`
+ * must carry. A global callback registers under a fixed module id (`space`, `state`, `navigation`, `auth`,
+ * `actions`) and NOT under the element hosting the flow: the runtime resolves one as
+ * `callbacksAvailables[elementId][action]`, so a node that stored the host element's id would resolve to
+ * nothing and the flow would silently do nothing.
+ *
+ * Here rather than with the catalog that gathers them (`@plitzi/sdk-authoring`) because a source declares its own
+ * and must not depend on the package that reads all five.
+ */
+export interface BuiltinGlobalCallback extends BuiltinActionSpec {
+    source: string;
+}
+/**
+ * A declared action, ready for `useInteractions` — everything but the function that runs it, which is the only
+ * part a source has to write.
+ */
+export declare const toInteractionCallback: <T extends Record<string, unknown> = Record<string, unknown>>(action: string, spec: BuiltinActionSpec, callback: InteractionCallback<T>["callback"], overrides?: Partial<InteractionCallback<T>>) => InteractionCallback<T>;
+/**
+ * Every declared action of one source, ready for `useInteractions`.
+ *
+ * The reason to build the whole map rather than call {@link toInteractionCallback} per entry: the key a callback is
+ * registered under IS the name a document names it by, and writing that key by hand beside a catalog that also
+ * names it is two strings that have to agree with nothing checking. They stopped agreeing for all three of the auth
+ * callbacks — declared `authLogin`, registered `login` — and the only symptom was a sign-in button that did
+ * nothing at all.
+ *
+ * Here the key comes from the catalog, and `handlers` is checked against the same keys, so a renamed action is a
+ * compile error and an unimplemented one cannot be registered.
+ */
+export declare const toInteractionCallbacks: <C extends Record<string, BuiltinActionSpec>>(catalog: C, handlers: { [K in keyof C]: (params: never, context?: InteractionCallbackContext) => unknown; }, overrides?: { [K in keyof C]?: Partial<InteractionCallback>; }) => Record<string, InteractionCallback>;

package/dist/authoring/builder.mjs

@@ -0,0 +1,29 @@
+//#region src/authoring/builder.ts
+var e = {
+	text: "text",
+	textarea: "textarea",
+	select: "select",
+	boolean: "boolean",
+	number: "text",
+	scalar: "text"
+}, t = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[-_\s]+/).map((e) => `${e.charAt(0).toUpperCase()}${e.slice(1)}`).join(" "), n = (n, r) => ({
+	type: r.builderType ?? e[r.type],
+	label: r.label ?? t(n),
+	...r.default === void 0 ? {} : { defaultValue: r.default },
+	...r.options ? { options: r.options.map((e) => ({
+		value: e,
+		label: r.optionLabels?.[e] ?? t(e)
+	})) } : {},
+	...r.when ? { when: r.when } : {},
+	...r.canBind === void 0 ? {} : { canBind: r.canBind }
+}), r = (e) => Object.fromEntries(Object.entries(e).map(([e, t]) => [e, n(e, t)])), i = (e, t, n, i = {}) => ({
+	action: e,
+	title: t.title,
+	type: t.type ?? "globalCallback",
+	callback: n,
+	preview: t.preview ?? {},
+	params: r(t.params),
+	...i
+}), a = (e, t, n = {}) => Object.fromEntries(Object.keys(e).map((r) => [r, i(r, e[r], t[r], n[r] ?? {})]));
+//#endregion
+export { r as toBuilderParams, i as toInteractionCallback, a as toInteractionCallbacks };

package/dist/authoring/declare.d.ts

@@ -0,0 +1,64 @@
+/**
+ * How an element says what it can be authored with.
+ *
+ * A declaration is data — `type`, default attributes, the metadata the builder shows — and the one thing it could
+ * not say until now is what those attributes *are*: `subType: 'h1'` in a default says `string`, not the six
+ * headings that exist. That type is already written and already maintained, on the element's own component, so
+ * this carries it rather than restating it: `elementDeclaration<HeadingAttributes>()({ … })` brands the
+ * declaration with the attributes it accepts, and every factory downstream reads them off the catalogue.
+ *
+ * A type-level brand rather than a field, because there is nothing to attach at runtime: a declaration is
+ * serialized into documents and manifests, and a marker with a value would travel with it. Nothing ever reads
+ * `__attributes` — it exists so `AttributesOf` has somewhere to look.
+ */
+export interface ElementAttributesBrand<A> {
+    readonly __attributes: A;
+}
+/** What every declaration is, whatever else it carries. */
+export interface ElementDeclarationData {
+    type: string;
+    /**
+     * The kind of data source this element publishes, when it publishes one.
+     *
+     * A source is named `<sourceType>_<id>`, and the two halves come from different places: the id is the
+     * author's, and this is the ELEMENT'S. They are not always the same word — a `form` publishes under
+     * `apiContainer`, because what it offers descendants is a record like any other provider's — so an author who
+     * assembles the name from the type they can see writes one that resolves to nothing.
+     *
+     * Declared here so there is one answer: the component reads it to register under, and the authoring surface
+     * reads it to resolve a binding that named the element alone.
+     */
+    sourceType?: string;
+    content?: {
+        attributes?: Record<string, unknown>;
+        definition?: {
+            label?: string;
+        };
+    };
+}
+/**
+ * The attributes a declaration accepts, defaulting to "anything" for one that never said.
+ *
+ * That default is the plugin case rather than an oversight: a type that arrives from a manifest at runtime has no
+ * TypeScript to offer, and refusing to author it would be worse than authoring it loosely.
+ */
+export type AttributesOf<D> = D extends ElementAttributesBrand<infer A> ? A : Record<string, unknown>;
+type AuthorableProps<Props, Injected extends keyof Props> = Omit<Props, 'ref' | 'className' | 'children' | Injected>;
+/**
+ * The authorable half of an element's props.
+ *
+ * `ref`, `className` and `children` are the element machinery's, not the author's — the first two are how a
+ * rendered element receives what the document already decided, and children are a tree, declared as one. Anything
+ * else a component is handed and the author does not choose (a form control's `value` and change handler, arriving
+ * from the form around it) is named per element, where the reason is visible.
+ *
+ * Everything comes out optional: an attribute left out is the declaration's default, which is the whole point of a
+ * declaration having them.
+ *
+ * A component with nothing authorable comes out `unknown`, not `{}`. A factory's props are these attributes
+ * intersected with the authoring fields, and `unknown` is what adds nothing to that intersection — while `{}` means
+ * "any value that is not null" everywhere else it could land.
+ */
+export type AuthorableAttributes<Props, Injected extends keyof Props = never> = keyof AuthorableProps<Props, Injected> extends never ? unknown : Partial<AuthorableProps<Props, Injected>>;
+export declare const elementDeclaration: <A>() => <const D extends ElementDeclarationData>(declaration: D) => D & ElementAttributesBrand<A>;
+export {};

package/dist/authoring/declare.mjs

@@ -0,0 +1,4 @@
+//#region src/authoring/declare.ts
+var e = () => (e) => e;
+//#endregion
+export { e as elementDeclaration };

package/dist/authoring/elementCallbacks.d.ts

@@ -0,0 +1,13 @@
+import { BuiltinActionSpec } from './builder';
+export type BuiltinElementCallback = BuiltinActionSpec;
+export declare const BUILTIN_ELEMENT_CALLBACKS: Record<string, BuiltinElementCallback>;
+/** The built-in element callback for an action, or undefined when the action is not a known built-in (an
+ *  element-type-specific/plugin callback whose schema is not knowable here). */
+export declare const getElementCallback: (action: string) => BuiltinElementCallback | undefined;
+/** Reconcile a `callback` action against the element-callback catalog: unknown keys dropped for a closed callback,
+ *  then missing defaults filled (category:"attribute", revertOnFinish:false). An unknown action yields unchanged
+ *  params, so a plugin/element-specific callback keeps whatever the agent passed. */
+export declare const applyElementCallback: (action: string, params: Record<string, unknown>) => {
+    known: boolean;
+    params: Record<string, unknown>;
+};

package/dist/authoring/elementCallbacks.mjs

@@ -0,0 +1,71 @@
+import { reconcileParams as e } from "./paramSpec.mjs";
+//#region src/authoring/elementCallbacks.ts
+var t = {
+	setState: {
+		title: "Update Element (set attribute / state)",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			category: {
+				type: "select",
+				description: "What to change on the element: \"attribute\" sets one of its props (the common case — e.g. content, disabled); \"state\" sets element state (visibility or a style selector). REQUIRED — always set it.",
+				default: "attribute",
+				options: ["attribute", "state"],
+				required: !0
+			},
+			key: {
+				type: "text",
+				description: "The field to set. When category=\"attribute\", an attribute/prop key of THIS element (e.g. \"content\", \"disabled\"). When category=\"state\", \"visibility\" or \"styleSelectors.<selector>\". REQUIRED.",
+				required: !0
+			},
+			value: {
+				type: "scalar",
+				description: "The value to set — its type follows the target attribute: a real boolean (true/false) for a boolean attribute, a number for a numeric one, otherwise a string (the strings \"true\"/\"false\" also coerce). There is NO separate `type` param (that belongs to the global state setState, not this one). REQUIRED.",
+				when: (e) => !!e.category,
+				required: !0
+			},
+			revertOnFinish: {
+				type: "boolean",
+				description: "When true, this change is UNDONE automatically when the whole flow finishes. Use it for a TEMPORARY change (a \"loading…\" label, disabling a button while it works) instead of adding manual restore steps at the end of the flow.",
+				default: !1,
+				label: "Revert changes after interaction"
+			}
+		}
+	},
+	toggleState: {
+		title: "Toggle Element (flip attribute / state)",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			category: {
+				type: "select",
+				description: "What to flip on the element: \"attribute\" flips one of its props (e.g. disabled); \"state\" flips element state (\"visibility\", or \"styleSelectors.<selector>\" for an expanded/collapsed look). REQUIRED.",
+				default: "state",
+				options: ["attribute", "state"],
+				required: !0
+			},
+			key: {
+				type: "text",
+				description: "The field to flip. When category=\"attribute\", an attribute/prop key of THIS element. When category=\"state\", \"visibility\" or \"styleSelectors.<selector>\". Anything not already true counts as false, so a field that has never been set flips ON first. REQUIRED.",
+				required: !0
+			},
+			revertOnFinish: {
+				type: "boolean",
+				description: "When true, the flip is UNDONE automatically when the whole flow finishes — a change that lasts only as long as the flow does.",
+				default: !1,
+				label: "Revert changes after interaction"
+			}
+		}
+	}
+}, n = (e) => Object.hasOwn(t, e) ? t[e] : void 0, r = (t, r) => {
+	let i = n(t);
+	return i ? {
+		known: !0,
+		params: e(r, i.params, i.strictParams)
+	} : {
+		known: !1,
+		params: r
+	};
+};
+//#endregion
+export { t as BUILTIN_ELEMENT_CALLBACKS, r as applyElementCallback, n as getElementCallback };

package/dist/authoring/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The authoring vocabulary a RUNTIME reads — the only part of authoring that is not in `@plitzi/sdk-authoring`.
+ *
+ * Everything else about authoring lives in that package, and this is here for one reason: each of these is read
+ * while a page renders, in a browser. An element declares itself with `elementDeclaration` (39 declaration files
+ * do), a source turns its declarations into the controls the builder draws with `toInteractionCallback`, and
+ * `getInteractions` reads the callbacks every element registers. If they lived with the rest of the authoring
+ * surface, `@plitzi/sdk-elements` and `@plitzi/sdk-interactions` would have to depend on the package that already
+ * depends on them — a cycle the build refuses.
+ *
+ * So they sit in the package everything already depends on, gathered in one folder rather than scattered through
+ * this one, and `@plitzi/sdk-authoring` re-exports every name below: an author still writes one import and never
+ * learns this boundary exists. What decides whether something belongs here is not what it is ABOUT but who reads
+ * it — a catalog nobody but an author reads (the CSS vocabulary, the element factories, the binding transformers)
+ * belongs over there, whatever it describes.
+ */
+export * from './builder';
+export * from './declare';
+export * from './elementCallbacks';
+export * from './paramSpec';
+export * from './spaceCallbacks';

package/dist/authoring/index.mjs

@@ -0,0 +1,6 @@
+import { toBuilderParams as e, toInteractionCallback as t, toInteractionCallbacks as n } from "./builder.mjs";
+import { elementDeclaration as r } from "./declare.mjs";
+import { hiddenParams as i, invalidParams as a, missingRequiredParams as o, reconcileParams as s } from "./paramSpec.mjs";
+import { BUILTIN_ELEMENT_CALLBACKS as c, applyElementCallback as l, getElementCallback as u } from "./elementCallbacks.mjs";
+import { spaceCallbacks as d } from "./spaceCallbacks.mjs";
+export { c as BUILTIN_ELEMENT_CALLBACKS, l as applyElementCallback, r as elementDeclaration, u as getElementCallback, i as hiddenParams, a as invalidParams, o as missingRequiredParams, s as reconcileParams, d as spaceCallbacks, e as toBuilderParams, t as toInteractionCallback, n as toInteractionCallbacks };

package/dist/authoring/paramSpec.d.ts

@@ -0,0 +1,51 @@
+import { InteractionParamType } from '../types';
+export type BuiltinParamType = 'text' | 'textarea' | 'select' | 'boolean' | 'number' | 'scalar';
+export interface BuiltinParam {
+    type: BuiltinParamType;
+    description: string;
+    default?: string | number | boolean;
+    options?: string[];
+    when?: (params: Record<string, unknown>) => boolean;
+    required?: boolean;
+    /** Overrides the label derived from the param name (`autoDismiss` → "Auto Dismiss"). */
+    label?: string;
+    /** Overrides the label derived from an option value (`top-right` → "Top Right"). */
+    optionLabels?: Record<string, string>;
+    /**
+     * The control the editor shows, when it is not the obvious one for `type` — including the case where it depends
+     * on what the author has already filled in (a value whose control follows the type they picked above it).
+     */
+    builderType?: InteractionParamType | ((params: Record<string, unknown>) => InteractionParamType);
+    /** Whether the editor offers to bind this param to a data source. Bindable unless a param says otherwise. */
+    canBind?: boolean;
+}
+export type ParamSpec = Record<string, BuiltinParam>;
+/** Declared params the agent supplied that end up HIDDEN because their own `when` guard is false against the
+ *  effective params — they are silently ignored (e.g. a global setState `value` with no `type`, or an
+ *  addNotification `autoDismissTimeout` with autoDismiss:false). Evaluated against the effective params so a param
+ *  the default fills in (e.g. category:"attribute") does not false-report a value as hidden. */
+export declare const hiddenParams: (provided: Record<string, unknown>, effective: Record<string, unknown>, spec: ParamSpec) => string[];
+/** Declared params marked `required` that the agent did NOT supply, and whose `when` guard holds against the
+ *  effective params (so they are actually in play). Evaluated against the effective params so a required param
+ *  gated by a companion (e.g. setState `value`, shown only once `category` is set) is not reported when its guard
+ *  is not met. */
+export declare const missingRequiredParams: (provided: Record<string, unknown>, effective: Record<string, unknown>, spec: ParamSpec) => string[];
+/** A param the agent supplied whose VALUE does not match its declared type — a boolean given as the string "true",
+ *  a number given as a string, a `select` value outside its options, a null placeholder left behind. `expected` is
+ *  the declared type, `got` the JS typeof (or "null"), and `options` the allowed values for a `select`. */
+export interface InvalidParam {
+    key: string;
+    expected: BuiltinParamType;
+    got: string;
+    options?: string[];
+}
+/** Declared params the agent supplied whose value is the WRONG type for the catalog — the check that catches a
+ *  malformed node the unknown/missing/hidden checks miss (a boolean stored as a string, a select value not in its
+ *  options, a leftover `null`). Only params actually in play are checked: undefined values (the param is absent) and
+ *  params hidden by their own `when` guard against the effective params are skipped, so this never fires on a param
+ *  that is not really used. Callers gate this to CLOSED (strict) catalogs, whose types we own authoritatively. */
+export declare const invalidParams: (provided: Record<string, unknown>, effective: Record<string, unknown>, spec: ParamSpec) => InvalidParam[];
+/** Reconcile supplied params to a catalog schema: drop unknown keys when the set is CLOSED (strict), then fill the
+ *  builder's defaults for any declared param the agent omitted whose `when` guard holds. Mirrors what the builder
+ *  stores, so the persisted node round-trips cleanly. */
+export declare const reconcileParams: (params: Record<string, unknown>, spec: ParamSpec, strict: boolean) => Record<string, unknown>;

package/dist/authoring/paramSpec.mjs

@@ -0,0 +1,40 @@
+import { hasValidToken as e } from "../helpers/twigWrapper/tokens/hasValidToken.mjs";
+//#region src/authoring/paramSpec.ts
+var t = (e, t, n) => {
+	let r = [];
+	for (let [i, a] of Object.entries(n)) a.when && e[i] !== void 0 && !a.when(t) && r.push(i);
+	return r;
+}, n = (e, t, n) => {
+	let r = [];
+	for (let [i, a] of Object.entries(n)) a.required && e[i] === void 0 && (!a.when || a.when(t)) && r.push(i);
+	return r;
+}, r = (e) => e.trim() !== "" && Number.isFinite(Number(e)), i = (t) => typeof t == "string" && e(t), a = (e, t) => {
+	switch (t.type) {
+		case "boolean": return typeof e == "boolean";
+		case "number": return typeof e == "number" || typeof e == "string" && r(e);
+		case "select": return typeof e == "string" && (!t.options || t.options.includes(e));
+		case "scalar": return typeof e == "string" || typeof e == "number" || typeof e == "boolean";
+		case "text":
+		case "textarea": return typeof e == "string";
+		default: return !0;
+	}
+}, o = (e, t, n) => {
+	let r = [];
+	for (let [o, s] of Object.entries(n)) {
+		let n = e[o];
+		n === void 0 || i(n) || s.when && !s.when(t) || a(n, s) || r.push({
+			key: o,
+			expected: s.type,
+			got: n === null ? "null" : typeof n,
+			...s.options ? { options: s.options } : {}
+		});
+	}
+	return r;
+}, s = (e, t, n) => {
+	let r = {};
+	for (let [i, a] of Object.entries(e)) (!n || i in t) && (r[i] = a);
+	for (let [e, n] of Object.entries(t)) n.default === void 0 || r[e] !== void 0 || n.when && !n.when(r) || (r[e] = n.default);
+	return r;
+};
+//#endregion
+export { t as hiddenParams, o as invalidParams, n as missingRequiredParams, s as reconcileParams };

package/dist/authoring/spaceCallbacks.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinGlobalCallback } from './builder';
+/**
+ * The `space` source, which the SDK application registers rather than this package.
+ *
+ * Its declaration lives here anyway, with the rest of the interaction vocabulary: the app supplies the function
+ * that shows a notification, and everything else about the action — its params, their defaults, what the editor
+ * shows — is the same knowledge every other source keeps here, and splitting it by which module happens to call
+ * `useInteractions` is how a catalog ends up being copied.
+ */
+export declare const spaceCallbacks: Record<string, BuiltinGlobalCallback>;

package/dist/authoring/spaceCallbacks.mjs

@@ -0,0 +1,51 @@
+//#region src/authoring/spaceCallbacks.ts
+var e = { addNotification: {
+	source: "space",
+	title: "Add Notification",
+	strictParams: !0,
+	params: {
+		content: {
+			type: "textarea",
+			description: "The notification text shown to the user — this is the message body. There is no separate title/message/type param.",
+			default: "Content"
+		},
+		placement: {
+			type: "select",
+			description: "Where the toast appears on screen.",
+			default: "top-right",
+			options: [
+				"top-right",
+				"top-center",
+				"top-left",
+				"bottom-right",
+				"bottom-center",
+				"bottom-left"
+			]
+		},
+		appeareance: {
+			type: "select",
+			description: "Visual style of the notification. NOTE: the key is spelled \"appeareance\".",
+			default: "success",
+			options: [
+				"success",
+				"danger",
+				"warning",
+				"info"
+			]
+		},
+		autoDismiss: {
+			type: "boolean",
+			description: "Whether the notification dismisses itself after a timeout.",
+			default: !0,
+			canBind: !1
+		},
+		autoDismissTimeout: {
+			type: "number",
+			description: "Milliseconds before auto-dismiss. Only applies when autoDismiss is true.",
+			default: 5e3,
+			when: (e) => e.autoDismiss === !0
+		}
+	}
+} };
+//#endregion
+export { e as spaceCallbacks };

package/dist/builder/contexts/BuilderContext.d.ts

@@ -1,8 +1,6 @@
-import { ComponentPluginWithHOC, DropPosition, Element, EventBridgeEvent, PluginBuilder, Schema, Style, StyleThemeMode } from '../../types';
+import { ComponentPluginWithHOC, DropPosition, Element, EventBridgeEvent, PluginBuilder, Schema, Style } from '../../types';
 import { Dispatch, SetStateAction } from 'react';
 export type BuilderContextValue = {
-    theme: StyleThemeMode;
-    setTheme: Dispatch<SetStateAction<StyleThemeMode>>;
     mode: 'normal' | 'template' | 'segment';
     schemaName: string;
     setMultiPagesMode: Dispatch<SetStateAction<boolean>>;
@@ -33,7 +31,7 @@ export type BuilderContextValue = {
             variables: Schema['variables'];
         }, dropPosition: DropPosition, toElementId: string, rootId?: string): boolean;
         <T extends string>(type: `add##${Exclude<T, 'plitzi-template'>}`, data: {
-            id: string;
+            id?: string;
             element: Element;
         }, dropPosition: DropPosition, toElementId: string, rootId?: string): boolean;
         <T extends string>(type: `move##${Exclude<T, 'plitzi-template'>}`, data: {

package/dist/dataSource/getBindingsDetails.mjs

@@ -21,7 +21,7 @@ var o = (e, t, r, i, a) => {
 		definition: d
 	}, (a) => {
 		Object.keys(f).forEach((c) => {
-			!f[c] || !Array.isArray(f[c]) || !f[c].length || f[c].forEach((l) => {
+			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));

package/dist/dataSource/helpers/getSourceName.d.ts

@@ -1,4 +1,2 @@
-declare const getSourceName: (type: string, element: {
-    idRef?: string;
-}) => string;
+declare const getSourceName: (type: string, id: string) => string;
 export default getSourceName;

package/dist/dataSource/helpers/getSourceName.mjs

@@ -1,4 +1,4 @@
 //#region src/dataSource/helpers/getSourceName.ts
-var e = (e, t) => t.idRef ? `${e}_${t.idRef}` : "";
+var e = (e, t) => `${e}_${t}`;
 //#endregion
 export { e as default };

package/dist/dataSource/index.d.ts

@@ -1,4 +1,6 @@
 export * from './hooks';
 export * from './helpers';
 export { default as getBindingsDetails } from './getBindingsDetails';
+export { default as resolveVariables } from './resolveVariables';
+export type { VariableScope } from './resolveVariables';
 export { default as utility, utilityOptions } from './utility';

package/dist/dataSource/index.mjs

@@ -1,5 +1,6 @@
-import e from "./helpers/getSourceName.mjs";
-import t from "./hooks/useRegisterSource.mjs";
-import n, { utilityOptions as r } from "./utility/index.mjs";
-import i from "./getBindingsDetails.mjs";
-export { i as getBindingsDetails, e as getSourceName, t as useRegisterSource, n as utility, r as utilityOptions };
+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 };

package/dist/dataSource/resolveVariables.d.ts

@@ -0,0 +1,22 @@
+import { SchemaVariable } from '../types';
+/** What a variable's `subValues` are matched against — everything a `when` rule may name. */
+export type VariableScope = {
+    routeParams?: Record<string, unknown>;
+    queryParams?: Record<string, unknown>;
+    hostname?: string;
+    environment?: string;
+};
+/**
+ * The space's variables, resolved for this request: `{ apiUrl: 'https://api.plitzi.local', … }`.
+ *
+ * A variable carries a default and a list of `subValues`, each guarded by a rule on the host, the environment or
+ * the request's params — which is how one document names an API that lives at a different address in every
+ * environment. The FIRST matching sub-value wins; with none, the default stands.
+ *
+ * It lives here, apart from the provider that publishes the result into the store, because two callers need it at
+ * different moments. `GlobalSources` publishes it for everything that renders. The router needs it BEFORE that:
+ * a page that sends an unauthenticated visitor to `{{authUrl}}/` is deciding not to render at all, so the
+ * provider that would have resolved the token never runs.
+ */
+export declare const resolveVariables: (variables: SchemaVariable[] | undefined, scope?: VariableScope) => Record<string, unknown>;
+export default resolveVariables;

package/dist/dataSource/resolveVariables.mjs

@@ -0,0 +1,16 @@
+import { QueryBuilderEvaluator as e } from "@plitzi/plitzi-ui/QueryBuilder";
+//#region src/dataSource/resolveVariables.ts
+var t = (t, n = {}) => Array.isArray(t) ? t.reduce((t, r) => {
+	let { name: i, value: a, subValues: o } = r;
+	if (!Array.isArray(o) || o.length === 0) return {
+		...t,
+		[i]: a
+	};
+	let s = o.find((t) => e(t.when, n));
+	return {
+		...t,
+		[i]: s ? s.value : a
+	};
+}, {}) : {};
+//#endregion
+export { t as default, t as resolveVariables };

package/dist/dataSource/utility/index.mjs

@@ -1,24 +1,26 @@
 import e from "./arrayMap.mjs";
 import t from "./capitalize.mjs";
 import n from "./dateConverter.mjs";
-import r from "./staticValue.mjs";
-import i from "./stringToArray.mjs";
-import a from "./styleSelector.mjs";
-import o from "./styleVariant.mjs";
-import s from "./twigTemplate.mjs";
+import r from "./not.mjs";
+import i from "./staticValue.mjs";
+import a from "./stringToArray.mjs";
+import o from "./styleSelector.mjs";
+import s from "./styleVariant.mjs";
+import c from "./twigTemplate.mjs";
 //#region src/dataSource/utility/index.ts
-var c = {
-	twigTemplate: s,
+var l = {
+	twigTemplate: c,
 	dateConverter: n,
-	staticValue: r,
+	staticValue: i,
 	capitalize: t,
 	arrayMap: e,
-	stringToArray: i,
-	styleSelector: a,
-	styleVariant: o
-}, l = Object.values(c).map(({ title: e, action: t }) => ({
+	stringToArray: a,
+	not: r,
+	styleSelector: o,
+	styleVariant: s
+}, u = Object.values(l).map(({ title: e, action: t }) => ({
 	label: e,
 	value: t
 }));
 //#endregion
-export { c as default, l as utilityOptions };
+export { l as default, u as utilityOptions };

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

@@ -0,0 +1,11 @@
+import { DataSourceUtility } from '../../types';
+/**
+ * The inverse of the value, as a boolean.
+ *
+ * A binding shows an element when its field is true and there is no "unless", so without this every condition a
+ * page reads has to arrive from the server in both polarities — `found` AND `missing`, `signedIn` AND `signedOut`.
+ * That is a field per question that exists only because the client could not say "not", and it puts the answer to
+ * "when is this hidden?" in a different repository from the page that hides it.
+ */
+declare const not: DataSourceUtility<unknown, boolean>;
+export default not;

package/dist/dataSource/utility/not.mjs

@@ -0,0 +1,15 @@
+//#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 = {
+	action: "not",
+	title: "Not",
+	type: "utility",
+	params: {},
+	preview: { content: "" },
+	callback: (e) => !t(e)
+};
+//#endregion
+export { n as default };

package/dist/devTools/debugCookie.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The cookie carrying the visitor's "hide the dev tools" preference — named for the origin it belongs to.
+ *
+ * A cookie's scope is the HOST, and the host has no port in it. So one jar entry is shared by every site served
+ * from `localhost`, and hiding the panel on the example running at `:5009` hides it on the one at `:4013` too —
+ * on the next reload, with nothing on screen to say why, and no way back that does not involve knowing the
+ * keyboard shortcut. Whoever hit that has a broken tool and no reason to suspect a cookie.
+ *
+ * The port goes in the NAME because it cannot go in the scope. A deployment on a default port is unaffected and
+ * keeps the plain name.
+ *
+ * Both halves of the SDK call this: the browser writes the preference, and the server reads it back so the
+ * markup it renders matches what the client is about to hydrate.
+ */
+export declare const debugCookieName: (host: string | undefined) => string;
+export default debugCookieName;

package/dist/devTools/debugCookie.mjs

@@ -0,0 +1,7 @@
+//#region src/devTools/debugCookie.ts
+var e = (e) => {
+	let t = e?.split(":")[1];
+	return t ? `plitzi_debug_${t}` : "plitzi_debug";
+};
+//#endregion
+export { e as debugCookieName, e as default };

package/dist/devTools/index.d.ts

@@ -1,5 +1,9 @@
+import { default as debugCookieName } from './debugCookie';
 import { default as DevToolsContext } from './DevToolsContext';
+import { default as isInteractionFlow } from './interactionLog';
 import { default as PlitziConsole } from './utils/PlitziConsole';
-export * from './utils/PlitziConsole';
+export * from './debugCookie';
 export * from './DevToolsContext';
-export { PlitziConsole, DevToolsContext };
+export * from './interactionLog';
+export * from './utils/PlitziConsole';
+export { PlitziConsole, DevToolsContext, debugCookieName, isInteractionFlow };