@plitzi/sdk-shared 0.37.2 → 0.37.4

package/dist/actions/access.d.ts

@@ -0,0 +1,12 @@
+import { ActionAccess } from '../types/ActionTypes';
+/** Who is asking, as far as access is concerned: whether they are signed in, and what they may do. */
+export type AccessCaller = {
+    permissions: readonly string[];
+} | undefined;
+/**
+ * Why a caller may not use something guarded by `access`, or `undefined` when they may.
+ *
+ * One reading of the access vocabulary for everything that speaks it — an action's trigger, a realtime channel — so
+ * `session` and `role` cannot come to mean two things in two places.
+ */
+export declare const accessRefusal: (access: ActionAccess | undefined, caller: AccessCaller) => "unauthenticated" | "forbidden" | undefined;

package/dist/actions/access.mjs

@@ -0,0 +1,13 @@
+//#region src/actions/access.ts
+var e = (e, t) => {
+	if (!e) return "forbidden";
+	if (e.mode !== "public") {
+		if (!t) return "unauthenticated";
+		if (e.mode === "role") {
+			let n = new Set(t.permissions);
+			return e.permissions.every((e) => n.has(e)) ? void 0 : "forbidden";
+		}
+	}
+};
+//#endregion
+export { e as accessRefusal };

package/dist/actions/functions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Where a space's functions answer HTTP: `GET /feed/:id` declared, `GET /api/feed/42` served. The path is
+ * the functions' and never a page's — the page server and the page linter both read it from here.
+ */
+export declare const FUNCTION_ROUTES_PREFIX = "/api";
+/** Whether a page at `path` would sit where the space's functions answer. */
+export declare const isFunctionRoutePath: (path: string) => boolean;
+/**
+ * Whether a path is one of a space's functions files: relative, inside `functions/`, a `.ts`, `.js`, `.mjs` or `.json`.
+ * The one rule for what a source is — the platform's build refuses anything else, and every reader of a working copy
+ * reads exactly this.
+ */
+export declare const isFunctionsSourcePath: (path: string) => boolean;
+/** How a reader reaches a directory, whatever it runs on: Node's `fs`, a test's map. */
+export type FunctionsSourceReader = {
+    list: (dir: string) => Promise<{
+        name: string;
+        directory: boolean;
+    }[]>;
+    read: (file: string) => Promise<string>;
+};
+/**
+ * A space's functions as a directory holds them — every source file under `root`, by its path there (`lib/feed.ts`),
+ * `node_modules` and dotted folders skipped. What a project's working copy is read as, by the CLI and by a server
+ * loading its own; a directory that is not there reads as none.
+ */
+export declare const readFunctionsSource: (root: string, reader: FunctionsSourceReader) => Promise<Record<string, string>>;

package/dist/actions/functions.mjs

@@ -0,0 +1,18 @@
+//#region src/actions/functions.ts
+var e = "/api", t = (e) => e === "/api" || e.startsWith("/api/"), n = (e) => /^[A-Za-z0-9_][A-Za-z0-9_./-]*\.(ts|js|mjs|json)$/.test(e) && !e.split("/").some((e) => e === ".." || e === "." || e === ""), r = async (e, t) => {
+	let r = {}, i = async (a) => {
+		let o;
+		try {
+			o = await t.list(a ? `${e}/${a}` : e);
+		} catch {
+			return;
+		}
+		for (let s of o) {
+			let o = a ? `${a}/${s.name}` : s.name;
+			s.directory ? s.name !== "node_modules" && !s.name.startsWith(".") && await i(o) : n(o) && (r[o] = await t.read(`${e}/${o}`));
+		}
+	};
+	return await i(""), r;
+};
+//#endregion
+export { e as FUNCTION_ROUTES_PREFIX, t as isFunctionRoutePath, n as isFunctionsSourcePath, r as readFunctionsSource };

package/dist/actions/index.d.ts

@@ -1,9 +1,13 @@
+export { accessRefusal } from './access';
 export { cronFiresBetween, cronMatches, cronNextFire, isKnownTimeZone, parseCron, zonedClock } from './cron';
 export { FAILURE_HANDLER_TASK } from './failureHandler';
+export { FUNCTION_ROUTES_PREFIX, isFunctionRoutePath, isFunctionsSourcePath, readFunctionsSource } from './functions';
 export { triggerAccess, triggerCacheMs, triggerHasStaleVerify, triggerInput, triggerVerify } from './triggerParams';
 export { actionName, actionTriggers, isActionEnabled } from './triggers';
 export { validateActionDocument } from './validateDocument';
 export { isSingleEmailAddress, readSmtpCredential, SMTP_CREDENTIAL_KEYS } from './smtp';
+export type { AccessCaller } from './access';
+export type { FunctionsSourceReader } from './functions';
 export type { CronExpression } from './cron';
 export type { SmtpCredentialProblem, SmtpCredentialReading, SmtpSecurity, SmtpSettings } from './smtp';
 export type { ActionDocumentIssue, ActionDocumentReport } from './validateDocument';

package/dist/actions/index.mjs

@@ -1,7 +1,9 @@
-import { cronFiresBetween as e, cronMatches as t, cronNextFire as n, isKnownTimeZone as r, parseCron as i, zonedClock as a } from "./cron.mjs";
-import { FAILURE_HANDLER_TASK as o } from "./failureHandler.mjs";
-import { triggerAccess as s, triggerCacheMs as c, triggerHasStaleVerify as l, triggerInput as u, triggerVerify as d } from "./triggerParams.mjs";
-import { actionName as f, actionTriggers as p, isActionEnabled as m } from "./triggers.mjs";
-import { validateActionDocument as h } from "./validateDocument.mjs";
-import { SMTP_CREDENTIAL_KEYS as g, isSingleEmailAddress as _, readSmtpCredential as v } from "./smtp.mjs";
-export { o as FAILURE_HANDLER_TASK, g as SMTP_CREDENTIAL_KEYS, f as actionName, p as actionTriggers, e as cronFiresBetween, t as cronMatches, n as cronNextFire, m as isActionEnabled, r as isKnownTimeZone, _ as isSingleEmailAddress, i as parseCron, v as readSmtpCredential, s as triggerAccess, c as triggerCacheMs, l as triggerHasStaleVerify, u as triggerInput, d as triggerVerify, h as validateActionDocument, a as zonedClock };
+import { accessRefusal as e } from "./access.mjs";
+import { cronFiresBetween as t, cronMatches as n, cronNextFire as r, isKnownTimeZone as i, parseCron as a, zonedClock as o } from "./cron.mjs";
+import { FAILURE_HANDLER_TASK as s } from "./failureHandler.mjs";
+import { FUNCTION_ROUTES_PREFIX as c, isFunctionRoutePath as l, isFunctionsSourcePath as u, readFunctionsSource as d } from "./functions.mjs";
+import { triggerAccess as f, triggerCacheMs as p, triggerHasStaleVerify as m, triggerInput as h, triggerVerify as g } from "./triggerParams.mjs";
+import { actionName as _, actionTriggers as v, isActionEnabled as y } from "./triggers.mjs";
+import { validateActionDocument as b } from "./validateDocument.mjs";
+import { SMTP_CREDENTIAL_KEYS as x, isSingleEmailAddress as S, readSmtpCredential as C } from "./smtp.mjs";
+export { s as FAILURE_HANDLER_TASK, c as FUNCTION_ROUTES_PREFIX, x as SMTP_CREDENTIAL_KEYS, e as accessRefusal, _ as actionName, v as actionTriggers, t as cronFiresBetween, n as cronMatches, r as cronNextFire, y as isActionEnabled, l as isFunctionRoutePath, u as isFunctionsSourcePath, i as isKnownTimeZone, S as isSingleEmailAddress, a as parseCron, d as readFunctionsSource, C as readSmtpCredential, f as triggerAccess, p as triggerCacheMs, m as triggerHasStaleVerify, h as triggerInput, g as triggerVerify, b as validateActionDocument, o as zonedClock };

package/dist/auth/index.d.ts

@@ -1,3 +1,4 @@
-export { createAuthFailureLink } from './authFailureLink';
 export { authFailureFromResponse, onAuthFailure, reportAuthFailure, sameRegistrableDomain } from './failureChannel';
+export { checkVisitorRoles, visitorAccess, VISITOR_NAME } from './visitorRoles';
 export type { AuthFailureListener, AuthFailureSignal } from './failureChannel';
+export type { VisitorRoles } from './visitorRoles';

package/dist/auth/index.mjs

@@ -1,3 +1,3 @@
 import { authFailureFromResponse as e, onAuthFailure as t, reportAuthFailure as n, sameRegistrableDomain as r } from "./failureChannel.mjs";
-import { createAuthFailureLink as i } from "./authFailureLink.mjs";
-export { e as authFailureFromResponse, i as createAuthFailureLink, t as onAuthFailure, n as reportAuthFailure, r as sameRegistrableDomain };
+import { VISITOR_NAME as i, checkVisitorRoles as a, visitorAccess as o } from "./visitorRoles.mjs";
+export { i as VISITOR_NAME, e as authFailureFromResponse, a as checkVisitorRoles, t as onAuthFailure, n as reportAuthFailure, r as sameRegistrableDomain, o as visitorAccess };

package/dist/auth/visitorRoles.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A space's visitor roles (`settings.visitorRoles`): each role a signed-in visitor may hold there, with the permissions
+ * it gives — what an action's `access: 'role'` and a page's `can()` are answered from.
+ *
+ * One reading of them for everyone who handles them: authoring refuses a space that writes them wrong, the builder's
+ * save refuses the same, and the server that resolves a visitor never reads a malformed map as a grant.
+ */
+export type VisitorRoles = Record<string, string[]>;
+/** A role or a permission: a name a person reads in the builder and an action names in its access rule. */
+export declare const VISITOR_NAME: RegExp;
+/** The roles as declared, or what is wrong with them — said so it can be fixed from the message alone. */
+export declare const checkVisitorRoles: (value: unknown) => {
+    ok: true;
+    roles: VisitorRoles;
+} | {
+    ok: false;
+    problem: string;
+};
+/**
+ * What a visitor holding `held` may do in a space that declares `declared`: the roles the space still declares, and
+ * every permission they give. A role the space no longer declares gives nothing — a grant outlives an edit of the
+ * roles, and must not outlive what it meant. Malformed roles give nothing at all.
+ */
+export declare const visitorAccess: (declared: unknown, held: readonly string[]) => {
+    roles: string[];
+    permissions: string[];
+};

package/dist/auth/visitorRoles.mjs

@@ -0,0 +1,48 @@
+//#region src/auth/visitorRoles.ts
+var e = /^[A-Za-z][\w-]{0,63}$/, t = "`visitorRoles: { author: [\"postPublish\"], editor: [\"postPublish\", \"postEdit\"] }`", n = (n) => {
+	if (typeof n != "object" || !n || Array.isArray(n)) return {
+		ok: !1,
+		problem: `\`settings.visitorRoles\` is ${JSON.stringify(n)}. Write each role with its permissions: ${t}.`
+	};
+	let r = {};
+	for (let [i, a] of Object.entries(n)) {
+		if (!e.test(i)) return {
+			ok: !1,
+			problem: `\`settings.visitorRoles\` has the role "${i}". A role is a name — a letter, then letters, digits, \`-\` or \`_\` — like "author".`
+		};
+		if (!Array.isArray(a) || a.length === 0) return {
+			ok: !1,
+			problem: `\`settings.visitorRoles.${i}\` is ${JSON.stringify(a)}. A role is the permissions it gives, as a list of names: ${t}.`
+		};
+		let n = /* @__PURE__ */ new Set();
+		for (let t of a) {
+			if (typeof t != "string" || !e.test(t)) return {
+				ok: !1,
+				problem: `\`settings.visitorRoles.${i}\` has ${JSON.stringify(t)}, which is not a permission name. Name it the way an action's \`access: 'role'\` asks for it, like "postPublish".`
+			};
+			if (n.has(t)) return {
+				ok: !1,
+				problem: `\`settings.visitorRoles.${i}\` names "${t}" twice.`
+			};
+			n.add(t);
+		}
+		r[i] = [...n];
+	}
+	return {
+		ok: !0,
+		roles: r
+	};
+}, r = (e, t) => {
+	let r = e === void 0 ? void 0 : n(e);
+	if (!r?.ok) return {
+		roles: [],
+		permissions: []
+	};
+	let i = [...new Set(t)].filter((e) => Object.hasOwn(r.roles, e));
+	return {
+		roles: i,
+		permissions: [...new Set(i.flatMap((e) => r.roles[e]))]
+	};
+};
+//#endregion
+export { e as VISITOR_NAME, n as checkVisitorRoles, r as visitorAccess };

package/dist/authoring/builder.mjs

@@ -6,6 +6,7 @@ var e = {
 	boolean: "boolean",
 	number: "text",
 	scalar: "text",
+	json: "codemirror-json",
 	elementIds: "elements"
 }, 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],

package/dist/authoring/declare.d.ts

@@ -1,4 +1,6 @@
 import { InteractionCallback } from '../types/InteractionTypes';
+import { PluginBuilder, PluginSchema } from '../types/PluginTypes';
+import { ElementDefinition } from '../types/SchemaTypes';
 /**
  * How an element says what it can be authored with.
  *
@@ -50,6 +52,15 @@ export interface ElementDeclarationData {
      * else it throws on its first render. A dropdown's panel, a tab container's header and body.
      */
     ancestorType?: string;
+    /**
+     * The values an enumerated attribute takes — a heading's `subType`, a link's `mode` — by attribute name.
+     *
+     * A component's props say this in TypeScript, which is gone at run time; an author writing JavaScript, a document
+     * that arrived as JSON or a value that went through a cast reaches the element anyway, and `subType: 'h7'` renders an
+     * `<h7>`. Written with {@link valuesOf}, so the list cannot drift from the props it mirrors; read by the authoring
+     * surface to refuse a value outside it.
+     */
+    attributeValues?: Record<string, readonly string[]>;
     content?: {
         attributes?: Record<string, unknown>;
         definition?: {
@@ -57,6 +68,39 @@ export interface ElementDeclarationData {
         };
     };
 }
+/**
+ * A plugin's declaration: an element of somebody's own, declared the way the built-in ones declare themselves.
+ *
+ * On top of what {@link ElementDeclarationData} says of any element it carries the whole `content`, because for a
+ * plugin that is also what gets PUBLISHED — its build writes it into `plugin-manifest.json`, which the builder, the page
+ * server and the MCP server read before they load any code. Data only, so that build can read it without React.
+ *
+ * `A` is the attributes the element accepts: its component's props, minus what the runtime supplies.
+ * `const declaration = { … } satisfies PluginDeclaration<SeatPickerAttributes>` then refuses a default the component
+ * does not take.
+ */
+export interface PluginDeclaration<A extends object = Record<string, unknown>> extends Omit<ElementDeclarationData, 'content'> {
+    content: {
+        /** The element's starting attributes — its component's defaults, where the builder can show them. */
+        attributes: A;
+        definition: Omit<ElementDefinition, 'rootId' | 'parentId' | 'interactions' | 'runtime' | 'loadStrategy'> & {
+            /** What the element is for, in a sentence: the builder shows it, and an agent reads it to choose the element. */
+            description?: string;
+        };
+        builder: PluginBuilder;
+        /** How the builder's catalogue shows the element. Whether it is verified is the platform's to say, never its own. */
+        market: {
+            category: string;
+            owner: string;
+            license: string;
+            website: string;
+            backgroundColor: string;
+            icon: string;
+        };
+        defaultStyle: PluginSchema['defaultStyle'];
+        settings?: Record<string, string | number | boolean>;
+    };
+}
 /**
  * The attributes a declaration accepts, defaulting to "anything" for one that never said.
  *
@@ -81,5 +125,14 @@ type AuthorableProps<Props, Injected extends keyof Props> = Omit<Props, 'ref' |
  * "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>>;
+/**
+ * Every value of a string-literal union, as a list — and a compile error when the list leaves one out.
+ *
+ * `valuesOf<NonNullable<ButtonProps['subType']>>()(['button', 'submit', 'reset'])`. A value outside the union is
+ * refused by the parameter type; one the union has and the list does not makes the argument ask for `missing`.
+ */
+export declare const valuesOf: <T extends string>() => <const V extends readonly T[]>(values: V & ([Exclude<T, V[number]>] extends [never] ? unknown : {
+    readonly missing: Exclude<T, V[number]>;
+})) => readonly string[];
 export declare const elementDeclaration: <A>() => <const D extends ElementDeclarationData>(declaration: D) => D & ElementAttributesBrand<A>;
 export {};

package/dist/authoring/declare.mjs

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

package/dist/authoring/index.mjs

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

package/dist/authoring/paramSpec.d.ts

@@ -1,5 +1,5 @@
 import { InteractionParamType } from '../types';
-export type BuiltinParamType = 'text' | 'textarea' | 'select' | 'boolean' | 'number' | 'scalar' | 'elementIds';
+export type BuiltinParamType = 'text' | 'textarea' | 'select' | 'boolean' | 'number' | 'scalar' | 'json' | 'elementIds';
 export interface BuiltinParam {
     type: BuiltinParamType;
     description: string;

package/dist/authoring/paramSpec.mjs

@@ -14,6 +14,7 @@ var t = (e, t, n) => {
 		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 "json": return typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "object" && !!e;
 		case "text":
 		case "textarea": return typeof e == "string";
 		case "elementIds": return Array.isArray(e) && e.every((e) => typeof e == "string");

package/dist/authoring/spaceCallbacks.mjs

@@ -22,9 +22,9 @@ var e = { addNotification: {
 				"bottom-left"
 			]
 		},
-		appeareance: {
+		appearance: {
 			type: "select",
-			description: "Visual style of the notification. NOTE: the key is spelled \"appeareance\".",
+			description: "Visual style of the notification: success, danger, warning or info.",
 			default: "success",
 			options: [
 				"success",

package/dist/dataSource/computed.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The space's computed values, from its definitions and the global sources they read.
+ *
+ * In declaration order, each one seeing the values before it as `computed.<name>` — so `level` can be written over
+ * `xp` without repeating it. A value that reads one declared after it reads nothing; authoring refuses that.
+ *
+ * Given the `previous` evaluation, a value that comes out the same keeps the object it was, and so does the whole
+ * when none changed. They are all evaluated again whenever the state changes, and a list or a record evaluates to a new
+ * object every time: every element reading one — a star on each of a hundred and sixty library items reading the
+ * favourites — rendered again for the tool in hand changing, because what it read was no longer the same object.
+ */
+export declare const evaluateComputed: (definitions: Record<string, string>, globals: Record<string, unknown>, previous?: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * The sources as a flow step reads them: `state` as the store holds it this instant, and `computed` evaluated over it.
+ *
+ * `runtime.sources` carries both as the last render left them — they are copied there after React renders — so a step
+ * reading them right after an earlier step wrote the state could see the value from before the write, or not,
+ * depending on whether React had rendered in between. Read here, a step always sees every write made before it: the
+ * flow's own and anything else that happened while it waited.
+ */
+export declare const liveSources: (sources: Record<string, unknown>, state: unknown, definitions: unknown) => Record<string, unknown>;

package/dist/dataSource/computed.mjs

@@ -0,0 +1,45 @@
+import { processTwigValue as e } from "../helpers/twigWrapper/processTwig/processTwig.mjs";
+import t from "@plitzi/plitzi-ui/utils/deepEqual";
+//#region src/dataSource/computed.ts
+var n = (n, r, i) => {
+	let a = {}, o = i !== void 0 && Object.keys(i).length === Object.keys(n).length;
+	for (let [s, c] of Object.entries(n)) {
+		let n = e(c, {
+			...r,
+			computed: { ...a }
+		}), l = i?.[s], u = i !== void 0 && Object.hasOwn(i, s) && (l === n || t(l, n));
+		a[s] = u ? l : n, o &&= u;
+	}
+	return o && i ? i : a;
+}, r = (e) => typeof e == "object" && !!e, i = (e) => r(e) && Object.values(e).every((e) => typeof e == "string"), a = [
+	"variables",
+	"navigation",
+	"auth",
+	"host",
+	"theme"
+], o = (e, t, n) => {
+	let a = r(t) ? t : {};
+	return i(n) ? {
+		...e,
+		state: a,
+		computed: c(n, e, a)
+	} : {
+		...e,
+		state: a
+	};
+}, s, c = (e, t, r) => {
+	let i = a.map((e) => t[e]);
+	if (s?.definitions === e && s.state === r && s.globals.every((e, t) => e === i[t])) return s.computed;
+	let o = n(e, {
+		...Object.fromEntries(a.map((e, t) => [e, i[t]])),
+		state: r
+	}, s?.definitions === e ? s.computed : void 0);
+	return s = {
+		definitions: e,
+		state: r,
+		globals: i,
+		computed: o
+	}, o;
+};
+//#endregion
+export { n as evaluateComputed, o as liveSources };

package/dist/dataSource/getBindingsDetails.mjs

@@ -1,44 +1,45 @@
-import e from "./utility/index.mjs";
-import { checkboxParams as t } from "./utility/checkboxParams.mjs";
-import { camelCase as n, get as r, set as i } from "@plitzi/plitzi-ui/helpers/lodash";
-import { QueryBuilderEvaluator as a } from "@plitzi/plitzi-ui/QueryBuilder";
-import { produce as o } 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 s = (e, t, n, 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 ? r(e, t, r(n, o)) : void 0,
-		toValue: r(n, o, t ? r(e, t) : void 0)
+		fromValue: t ? i(e, t, i(n, o)) : void 0,
+		toValue: i(n, o, t ? i(e, t) : void 0)
 	};
-}, c = (r, 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
-	} : o({
-		attributes: u,
-		style: l,
-		definition: d
-	}, (o) => {
-		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 && !a(f, r, !1, !0) || !p) return;
-				c === "style" && (m = n(m));
-				let { fromValue: h, toValue: g } = s(r, u, o, c, m), _ = h;
-				d && Array.isArray(d) && d.length > 0 && d.forEach((n) => {
-					let { action: i, params: a, enabled: s = !0 } = n;
-					if (!s) return;
-					let c = e[i];
-					c && (_ = c.callback(_, t(c, a) ?? {}, o, {
-						...r,
-						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" ? i(o, `definition.${c}.${m}`, _) : i(o, `${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 { c 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/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 };