@plitzi/sdk-shared 0.38.11 → 0.38.13

package/CHANGELOG.md

@@ -1,5 +1,115 @@
 # @plitzi/sdk-shared
 
+## 0.38.13
+
+### Patch Changes
+
+- v0.38.13
+
+## 0.38.12
+
+### Patch Changes
+
+- 1301338: ## Builder
+
+  - **Icons in the canvas again** (`@plitzi/plitzi-builder`): the canvas inlined the SDK's Font Awesome sheet into its
+    `<style>`, where the sheet's `url(webfonts/…)` resolved against the editor's URL — a `srcdoc` frame takes it as its
+    base — so every icon was a 404 under `/spaces/<space>/webfonts/` and drew as an empty box. Only the Vite dev server,
+    which rewrites the URL, hid it. The canvas and the element preview now link the sheet from where the host serves it:
+    a new prop, `sdkIconsStylePath`, the one the host already gives the pages it renders
+    (`/sdk-assets/plitzi-sdk-icons.css` for sdk-server). Absent, the canvas links no icon sheet.
+
+  ## Plugins
+  - **A plugin's other elements, hosted by `custom`** (`@plitzi/sdk-elements`): `custom({ renderType: 'jamDisc' })` on a
+    space with a plugin installed whose main element is another (`plitzi plugin pack` of several folders: the first is the
+    plugin, the rest go in it) rendered "Custom Component jamDisc Not Found" — the page registers only the plugin's main
+    element, and a `custom` host looked nowhere else. It now loads the type from the installed plugin that packs it, as
+    an element of the type itself always did, so the two ways the docs give to place a plugin's element are the same
+    everywhere: in a project `plitzi create` wrote, and once the project is on Plitzi.
+  - **One way to place a plugin's element** (`@plitzi/sdk-authoring`, `@plitzi/cli`, docs): from its declaration,
+    `const seatPicker = defineElement(declaration)` then `seatPicker({ id, … })` — typed by what it
+    declares, and the element the builder adds when somebody drops it. The welcome space `plitzi create` writes, the
+    plugin package's preview, `plitzi plugin add` and `plitzi explain` all write it so (the template's
+    `PluginHostOptions` now takes the plugin's `type` and `declaration: { from, attributes? }`; `custom`/`element` hosting
+    is gone). `pluginFolders(folder)` (`@plitzi/sdk-authoring/node`) reads each plugin with the folder it is in;
+    `pluginDeclarations` is built on it. A `custom({ renderType })` naming a plugin the space was handed the declaration
+    of is offered the declaration instead — suggestion `plugin-custom-host`. `custom` stays for a component registered
+    by name with no declaration. The skills, the CLI README, the MCP guide, `docs/en` and the website say the same.
+  - **`definePlugin`** (`@plitzi/sdk-authoring/plugin`, a new entry of 3 KB with nothing else in it): a plugin's
+    declaration written from what only it can say —
+    `definePlugin<SeatPickerAttributes>()({ type, label, attributes, triggers, callbacks })` — and every other field
+    at the default all plugins share (the builder's gestures, the catalogue entry, each attribute bindable, an empty
+    style). It answers the whole declaration, branded with its attributes, so `defineElement(declaration)` is typed
+    without a generic. `plitzi plugin add` and `create --plugin` write declarations with it (about a third of the lines).
+  - **`usePluginTrigger(declaration)`** (`@plitzi/plitzi-sdk`): fires a plugin's declared event on its element — the
+    event name and what each hands a flow typed off the declaration's `preview` — on a live page only. The hook every
+    plugin wrote for itself (and `plugin add` generated as `use<Name>Events`) is gone from the scaffold.
+  - **Attributes as the types their defaults are** (`@plitzi/sdk-elements`): a plugin's attribute bound from text — a
+    state, a row, a channel message — reaches its component as the number or the flag its declared default is (`'112'`
+    as 112, `'true'` as true). A plugin no longer types its props `number | string` and parses them.
+
+  ## Server actions and functions
+  - **Task params with rules** (`@plitzi/sdk-server`, `@plitzi/sdk-shared`): a task declares `required`, a text's
+    `maxLength` and a number's `min`/`max`, and the runner refuses a call that breaks any of them — every rule broken at
+    once, in the words the page shows (`Title is required; Seconds is at most 300`) — before the code runs. A `text` param
+    bound to a number arrives as its digits. The manifest keeps the rules, so the platform's sandbox checks the same.
+  - **`taskAction(task, { trigger })`** (`@plitzi/sdk-authoring`): the action that runs one of the space's tasks and
+    answers its result, derived from the task — its id (`<namespace>-<action>`), name, description and input (the task's
+    params, once). An action of more than one step is still `defineAction`.
+  - **`ctx.rateLimit(bucket, { …, refuse })`**: past the limit the call is refused with those words instead of answering
+    `allowed: false` for the code to check — natively and in the sandbox.
+
+  ## Authoring
+  - **`runServerActionOrNotify(id, params, fallback)`**: a server action run and the notice the visitor reads when it
+    fails — the action's own refusal, or the fallback — as two steps to spread into a flow.
+  - **`repeated-shape` reads what copies bind**: copies whose bindings read their data in different forms (a count, a
+    total of a quota) and copies holding a provider resolved on the server (found by its own id) are no longer offered
+    as one component.
+  - **`element-color-inherited`** (suggestion): `elements` giving a heading, a text, a link… `color: inherit` or the
+    page's own colour. **A link inherits the page's colour** (`@plitzi/plitzi-sdk`, `@plitzi/sdk-elements`) rather than
+    holding the SDK's grey — the same by default, and the space's palette inside a card that is a link. The template
+    every space starts from writes its colours once, on the page.
+
+  ## Fixes
+  - **A dialog opened with an id** (`@plitzi/sdk-elements`): `openDialog('dialog', '{{ row.id }}')` reads the id as its
+    `content`, as `openModal` already did — a numeric id parsed as the number and the dialog's bindings read nothing.
+  - **A select's chevron** (`@plitzi/plitzi-sdk`): a drawn chevron in the field's own colour, sized by its type, in place
+    of the `▼` glyph — and laid out in the box, so it ends where the box's padding begins whatever that padding is, and
+    the chosen option stops short of it instead of running under it. A disabled select's is faded.
+  - **Every element has its settings** (`@plitzi/plitzi-builder`, `@plitzi/sdk-elements`): the builder found none for
+    `tabContainerHeader` (registered under a misspelt type), `themeToggle`, `dropdownPopup`, `loading` and `notFound`.
+    The theme toggle's panel sets its mode, its labels and whether it offers "System"; the registry is typed by element
+    type and must hold one for each.
+  - **A plugin's panel** (`@plitzi/cli`): `plitzi doctor` warns of a plugin with no `Settings.tsx`, or one its entry never
+    passes as `pluginSettings` (`plugin-settings-missing`); the example `create` writes has its panel, as every element
+    `plugin add` writes does, and the panels it generates are laid out as the project's Prettier lays them out.
+  - **A refused or failed run reaches `onFlowError` in every mode** (`@plitzi/sdk-interactions`): an awaited server
+    action the server refused fired no `onFlowError` on the element that started it, as `detached` and `stream` ones do
+    — a board rolling its edits back on a refusal never did; and a run answered `status: 'failed'` fired `onFlowEnd`
+    (detached) or nothing (awaited) rather than `onFlowError`.
+  - **A source renamed** (`@plitzi/sdk-shared`): the binding picker lists a provider, a form or a modal by the name its
+    element has now, not the one it had when it mounted.
+  - **A text's words in the builder** (`@plitzi/sdk-elements`): a `paragraph`, `text` or `heading` whose `content` is
+    `0` shows `0` while editing too, not its placeholder; one bound to nothing shows nothing rather than `null`.
+  - **Built-in declarations** (`@plitzi/sdk-shared`): `elementDeclaration` fills in what every element shares — the
+    builder's gestures, Plitzi's catalogue entry, a visible element with no bindings, its style named by its label —
+    from the defaults `definePlugin` uses; each element's declaration says only what is its own (a third of the lines).
+
+  ## Typed for plugins and hosts
+  - **`usePlitzi()` and `PlitziProvider`** (`@plitzi/sdk-shared/hooks/usePlitzi`, `@plitzi/plitzi-sdk`): what were
+    `usePlitziServiceContext()` and `PlitziServiceProvider` (and `PlitziServiceContextValue`, now `PlitziContextValue`),
+    holding only what the host rendering a space knows — `settings`, `root`, `utils`. Its `contexts` and
+    `customContexts` are gone: every context it carried is a shared one already, imported from its own module
+    (`@plitzi/sdk-interactions/InteractionsContext`, `@plitzi/sdk-shared/network/NetworkContext`…), and
+    `PluginsContext` moves to `@plitzi/sdk-shared/plugins/PluginsContext` beside the others.
+  - **`InteractionsManagerApi`** (`@plitzi/sdk-shared`): the interactions manager as everything outside
+    `@plitzi/sdk-interactions` reaches it, declared where every package can name it and implemented by
+    `InteractionsManager`, so `use(InteractionsContext)` is typed — `interactionTrigger`, `createChildManager`… — where it
+    was `any`.
+  - **`getPathsFromObject`** (`@plitzi/sdk-shared/helpers/utils`), spelt right; `getPathsFromObeject` is gone.
+  - **`ElementWords` places itself** (`@plitzi/sdk-elements`): `contentPlacement` and the element's children, so a button
+    and a link write their words once.
+
 ## 0.38.11
 
 ### Patch Changes

package/dist/authoring/declare.d.ts

@@ -1,6 +1,7 @@
-import { InteractionCallback } from '../types/InteractionTypes';
+import { InteractionCallback, InteractionCallbackPreviews } from '../types/InteractionTypes';
 import { PluginBuilder, PluginSchema } from '../types/PluginTypes';
 import { ElementDefinition } from '../types/SchemaTypes';
+import { DisplayMode, StyleAttributes } from '../types/StyleTypes';
 /**
  * How an element says what it can be authored with.
  *
@@ -148,5 +149,154 @@ export type AuthorableAttributes<Props, Injected extends keyof Props = never> =
 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>;
+/** What a built-in element writes in its declaration's `content`: what is its own — the rest is filled in. */
+export interface ElementContentSpec {
+    attributes: Record<string, unknown>;
+    /** Left out: `type` (the declaration's), no bindings, visible, and the `base` style selector beside its own. */
+    definition: Omit<Partial<ElementDefinition>, 'type' | 'rootId' | 'parentId' | 'interactions' | 'runtime' | 'styleSelectors'> & {
+        label: string;
+        /** What the element is for, in a sentence: the builder shows it, and an agent reads it to choose the element. */
+        description?: string;
+        styleSelectors?: Record<string, string>;
+    };
+    /** Left out, every gesture, and children of any type. */
+    builder?: PluginBuilder;
+    /** Its place in the catalogue; the rest is Plitzi's own entry. */
+    market: {
+        category: string;
+        icon: string;
+    };
+    /** Left out: named by its label, for desktop. */
+    defaultStyle: {
+        name?: string;
+        displayMode?: DisplayMode;
+        style: StyleAttributes;
+        /** A style of its own for each `subType` — a heading's `h1`… — written whole. */
+        subTypes?: Record<string, {
+            name: string;
+            displayMode: DisplayMode;
+            style: StyleAttributes;
+        }>;
+    };
+    settings?: Record<string, string | number | boolean>;
+}
+/** What {@link elementDeclaration} takes: the declaration as written, `content` holding only what is the element's. */
+export interface ElementDeclarationSpec extends Omit<ElementDeclarationData, 'content'> {
+    content: ElementContentSpec;
+}
+/** What {@link elementDeclaration} fills in, typed as the declaration then carries it. */
+export interface ElementContentDefaults {
+    definition: {
+        type: string;
+        bindings: NonNullable<ElementDefinition['bindings']>;
+        initialState: Record<string, unknown>;
+        styleSelectors: Record<string, string> & {
+            base: string;
+        };
+    };
+    builder: Required<PluginBuilder>;
+    market: {
+        owner: string;
+        verified: boolean;
+        license: string;
+        website: string;
+        backgroundColor: string;
+    };
+    defaultStyle: {
+        name: string;
+        displayMode: DisplayMode;
+    };
+    settings: Record<string, string | number | boolean>;
+}
+/** A built-in element's whole declaration: what it wrote, what was filled in, and the attributes it accepts. */
+export type DeclaredElement<D extends ElementDeclarationSpec, A> = D & {
+    content: ElementContentDefaults;
+} & ElementAttributesBrand<A>;
+/**
+ * A built-in element's declaration, written from what is its own — its type, words, attributes, style, place in the
+ * catalogue — with the rest at the defaults every element shares: the builder's gestures, Plitzi's catalogue entry,
+ * a visible element with no bindings, its style named by its label.
+ *
+ * Called twice, as {@link definePlugin} is: the first call takes the attributes the element accepts, the second the
+ * declaration.
+ */
+export declare const elementDeclaration: <A>() => <const D extends ElementDeclarationSpec>(declaration: D) => DeclaredElement<D, A>;
+/** An event a plugin fires, as {@link definePlugin} takes it: what a flow it starts reads (`preview`) — the rest derived. */
+export type PluginTriggerSpec = {
+    /** Left out, the event's name in words: `onEdit` is "On Edit". */
+    title?: string;
+    /** What a flow started by it reads, `{ ops: '' }` — and so what the plugin hands it (`usePluginTrigger`). */
+    preview?: InteractionCallbackPreviews;
+    params?: InteractionCallback['params'];
+};
+/** An action a plugin answers, as {@link definePlugin} takes it: its params — the rest derived. */
+export type PluginCallbackSpec = {
+    title?: string;
+    params?: InteractionCallback['params'];
+};
+type PluginContent<A extends object> = PluginDeclaration<A>['content'];
+/** What a plugin is, said once: {@link definePlugin} writes the rest of its declaration from it. */
+export interface PluginSpec<A extends object, T extends Record<string, PluginTriggerSpec>, C extends Record<string, PluginCallbackSpec>> extends Omit<ElementDeclarationData, 'type' | 'triggers' | 'callbacks' | 'content'> {
+    /** What a space names it by — the element type. Renaming it orphans every one. */
+    type: string;
+    /** What the builder's catalogue calls it. */
+    label: string;
+    /** What it is for, in a sentence: the builder shows it, and an agent reads it to choose the element. */
+    description?: string;
+    /** Its starting attributes: the component's defaults. */
+    attributes: A;
+    triggers?: T;
+    callbacks?: C;
+    /** What the builder lets a person do with it. Left out, every gesture, and no children. */
+    builder?: PluginBuilder;
+    /** How the catalogue shows it. Left out, under its label, by nobody, MIT. */
+    market?: Partial<PluginContent<A>['market']>;
+    /** The attributes a data source may be pointed at. Left out, every one. */
+    bindable?: readonly (keyof A & string)[];
+    /** Its style before anybody styles it. */
+    style?: PluginSchema['defaultStyle']['style'];
+    /** More of the element's definition — children it starts with (`items`), its style selectors. */
+    definition?: Partial<PluginContent<A>['definition']>;
+    settings?: PluginContent<A>['settings'];
+}
+/** A plugin's events and actions as its declaration carries them: each named by its key, its preview kept as written. */
+export type DeclaredTriggers<T extends Record<string, PluginTriggerSpec>> = {
+    [K in keyof T & string]: Omit<InteractionCallback, 'action' | 'preview'> & {
+        action: K;
+        preview: T[K]['preview'] extends object ? T[K]['preview'] : Record<string, never>;
+    };
+};
+export type DeclaredCallbacks<C extends Record<string, PluginCallbackSpec>> = {
+    [K in keyof C & string]: Omit<InteractionCallback, 'action'> & {
+        action: K;
+    };
+};
+/** What {@link definePlugin} answers: the declaration, its events and actions named, and its attributes in its type. */
+export type DefinedPlugin<A extends object, T extends Record<string, PluginTriggerSpec>, C extends Record<string, PluginCallbackSpec>> = Omit<PluginDeclaration<A>, 'triggers' | 'callbacks'> & {
+    triggers: DeclaredTriggers<T>;
+    callbacks: DeclaredCallbacks<C>;
+} & ElementAttributesBrand<A>;
+/**
+ * A plugin's declaration, written from what only it can say — its type, its words, its attributes, what it fires and
+ * answers — with everything else at the default every plugin shares: the builder's gestures, the catalogue entry, a
+ * bindable attribute for each one, an empty style.
+ *
+ * ```ts
+ * export default definePlugin<SeatPickerAttributes>()({
+ *   type: 'seatPicker',
+ *   label: 'Seat Picker',
+ *   description: 'Picks a seat from a plan.',
+ *   attributes: { start: 0, label: 'Seats' },
+ *   triggers: { onPick: { preview: { seat: '' } } },
+ *   callbacks: { reset: {} }
+ * });
+ * ```
+ *
+ * Called twice, as `elementDeclaration` is: the first call takes the attributes the element accepts (its component's
+ * props, minus what the runtime supplies), which TypeScript cannot read off defaults that leave some out; the second the
+ * rest, whose events it reads as written. The whole declaration comes back — what the build writes into the manifest
+ * and the builder reads — branded with the attributes, so `defineElement(declaration)` authors the element typed
+ * without being told.
+ */
+export declare const definePlugin: <A extends object>() => <const T extends Record<string, PluginTriggerSpec> = never, const C extends Record<string, PluginCallbackSpec> = never>({ type, label, description, attributes, triggers, callbacks, builder, market, bindable, style, definition, settings, ...rest }: PluginSpec<A, T, C>) => DefinedPlugin<A, T, C>;
 export {};

package/dist/authoring/declare.mjs

@@ -1,4 +1,97 @@
 //#region src/authoring/declare.ts
-var e = () => (e) => e, t = () => (e) => e;
+var e = () => (e) => e, t = () => ({
+	canDelete: !0,
+	canSelect: !0,
+	canDragDrop: !0,
+	canMove: !0,
+	canSnippet: !0,
+	itemsAllowed: [],
+	itemsNotAllowed: []
+}), n = (e, t) => ({
+	type: e,
+	bindings: {},
+	initialState: { visibility: !0 },
+	...t,
+	styleSelectors: {
+		base: "",
+		...t.styleSelectors
+	}
+}), r = () => (e) => {
+	let { definition: r, builder: i, market: a, defaultStyle: o, settings: s } = e.content;
+	return {
+		...e,
+		content: {
+			...e.content,
+			definition: n(e.type, r),
+			builder: {
+				...t(),
+				...i
+			},
+			market: {
+				owner: "Plitzi",
+				verified: !0,
+				license: "MIT",
+				website: "https://plitzi.com",
+				backgroundColor: "#4422ee",
+				...a
+			},
+			defaultStyle: {
+				name: r.label,
+				displayMode: "desktop",
+				...o
+			},
+			settings: s ?? {}
+		}
+	};
+}, i = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (e) => e.toUpperCase()), a = () => ({ type: e, label: r, description: a, attributes: o, triggers: s, callbacks: c, builder: l, market: u, bindable: d, style: f, definition: p, settings: m, ...h }) => {
+	let g = (e, t, n) => ({
+		action: t,
+		title: n.title ?? i(t),
+		type: e,
+		params: n.params ?? {},
+		...e === "trigger" ? { preview: n.preview ?? {} } : {}
+	}), _ = d ?? Object.keys(o);
+	return {
+		...h,
+		type: e,
+		triggers: Object.fromEntries(Object.entries(s ?? {}).map(([e, t]) => [e, g("trigger", e, t)])),
+		callbacks: Object.fromEntries(Object.entries(c ?? {}).map(([e, t]) => [e, g("callback", e, t)])),
+		content: {
+			attributes: o,
+			definition: n(e, {
+				label: r,
+				...a ? { description: a } : {},
+				items: [],
+				...p
+			}),
+			builder: {
+				...t(),
+				...l
+			},
+			market: {
+				category: r,
+				owner: "",
+				license: "MIT",
+				website: "",
+				backgroundColor: "#4422ee",
+				icon: "",
+				...u
+			},
+			defaultStyle: {
+				name: r,
+				displayMode: "desktop",
+				style: f ?? { base: { default: {} } },
+				bindingsAllowed: {
+					attributes: _.map((e) => ({
+						path: e,
+						label: i(e)
+					})),
+					initialState: []
+				}
+			},
+			settings: m ?? {}
+		}
+	};
+};
 //#endregion
-export { t as elementDeclaration, e as valuesOf };
+export { a as definePlugin, r 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, valuesOf as i } from "./declare.mjs";
-import { BUILTIN_PARAM_TYPES as a, hiddenParams as o, invalidParams as s, missingRequiredParams as c, reconcileParams as l } from "./paramSpec.mjs";
-import { BUILTIN_ELEMENT_CALLBACKS as u, SCROLL_CALLBACKS as d, applyElementCallback as f, getElementCallback as p } from "./elementCallbacks.mjs";
-import { spaceCallbacks as m } from "./spaceCallbacks.mjs";
-export { u as BUILTIN_ELEMENT_CALLBACKS, a as BUILTIN_PARAM_TYPES, d as SCROLL_CALLBACKS, f as applyElementCallback, r as elementDeclaration, p as getElementCallback, o as hiddenParams, s as invalidParams, c as missingRequiredParams, l as reconcileParams, m as spaceCallbacks, e as toBuilderParams, t as toInteractionCallback, n as toInteractionCallbacks, i as valuesOf };
+import { definePlugin as r, elementDeclaration as i, valuesOf as a } from "./declare.mjs";
+import { BUILTIN_PARAM_TYPES as o, hiddenParams as s, invalidParams as c, missingRequiredParams as l, reconcileParams as u } from "./paramSpec.mjs";
+import { BUILTIN_ELEMENT_CALLBACKS as d, SCROLL_CALLBACKS as f, applyElementCallback as p, getElementCallback as m } from "./elementCallbacks.mjs";
+import { spaceCallbacks as h } from "./spaceCallbacks.mjs";
+export { d as BUILTIN_ELEMENT_CALLBACKS, o as BUILTIN_PARAM_TYPES, f as SCROLL_CALLBACKS, p as applyElementCallback, r as definePlugin, i as elementDeclaration, m as getElementCallback, s as hiddenParams, c as invalidParams, l as missingRequiredParams, u as reconcileParams, h as spaceCallbacks, e as toBuilderParams, t as toInteractionCallback, n as toInteractionCallbacks, a as valuesOf };

package/dist/dataSource/hooks/useRegisterSource.mjs

@@ -1,27 +1,40 @@
 import { makeId as e } from "../../helpers/utils.mjs";
-import { useEffect as t, useMemo as n } from "react";
-import { createStoreHook as r } from "@plitzi/nexus/react";
+import { useEffect as t, useEffectEvent as n, useMemo as r } from "react";
+import { createStoreHook as i } from "@plitzi/nexus/react";
 //#region src/dataSource/hooks/useRegisterSource.ts
-var i = ({ id: i = "", source: a, name: o, fields: s = [] }) => {
-	let { useStoreSetter: c } = r(), l = c(), u = n(() => `${i}_${e(8)}`, [i]);
-	t(() => {
-		if (a) return l(`sources.${u}`, {
-			id: u,
+var a = ({ id: a = "", source: o, name: s, fields: c = [] }) => {
+	let { useStoreSetter: l } = i(), u = l(), d = r(() => `${a}_${e(8)}`, [a]), f = n(() => {
+		u(`sources.${d}`, {
+			id: d,
 			meta: {
-				id: i,
-				source: a,
-				name: o,
-				fields: s
+				id: a,
+				source: o,
+				name: s,
+				fields: c
 			}
-		}), () => l(`sources.${u}`, void 0, { unmount: !0 });
-	}, [u, a]), t(() => {
-		a && l(`sources.${u}.meta.fields`, s, { raw: !0 });
+		});
+	});
+	t(() => {
+		if (o) return f(), () => u(`sources.${d}`, void 0, { unmount: !0 });
+	}, [
+		d,
+		o,
+		u
+	]), t(() => {
+		o && u(`sources.${d}.meta.name`, s);
 	}, [
 		s,
-		a,
-		u,
-		l
+		o,
+		d,
+		u
+	]), t(() => {
+		o && u(`sources.${d}.meta.fields`, c, { raw: !0 });
+	}, [
+		c,
+		o,
+		d,
+		u
 	]);
 };
 //#endregion
-export { i as default };
+export { a as default };

package/dist/helpers/generateFacade.mjs

@@ -1,9 +1,13 @@
-import { omit as e } from "@plitzi/plitzi-ui/helpers";
+import { isRecord as e } from "./isRecord.mjs";
+import { omit as t } from "@plitzi/plitzi-ui/helpers";
 //#region src/helpers/generateFacade.tsx
-var t = (e) => e.replace(/^@/, "").replace(/[-/]/g, " ").replace(/\b\w/g, (e) => e.toUpperCase()).replace(/\s+/g, ""), n = (e, t = "PlitziFacade") => {
-	let n = typeof window < "u" ? Object.keys(window[t]?.[e] ?? {}) : [];
+var n = (e) => e.replace(/^@/, "").replace(/[-/]/g, " ").replace(/\b\w/g, (e) => e.toUpperCase()).replace(/\s+/g, ""), r = (t, n) => {
+	let r = Reflect.get(window, t), i = e(r) ? r[n] : void 0;
+	return e(i) ? i : {};
+}, i = (e, t = "PlitziFacade") => {
+	let n = typeof window < "u" ? Object.keys(r(t, e)) : [];
 	return n.length === 0 ? "" : `export default window.${t}.${e};${n.filter((e) => e !== "default").map((n) => `export const ${n} = window.${t}.${e}.${n};`).join("")}`;
-}, r = (e) => URL.createObjectURL(new Blob([e], { type: "application/javascript" })), i = () => {
+}, a = (e) => URL.createObjectURL(new Blob([e], { type: "application/javascript" })), o = () => {
 	let e = {};
 	return typeof document > "u" || document.querySelectorAll("script[type=\"importmap\"]").forEach((t) => {
 		if (t.textContent) try {
@@ -15,21 +19,21 @@ var t = (e) => e.replace(/^@/, "").replace(/[-/]/g, " ").replace(/\b\w/g, (e) =>
 			console.error("Invalid importmap JSON", e);
 		}
 	}), e;
-}, a = (e, i = "PlitziFacade") => JSON.stringify({ imports: Object.keys(e).map((e) => ({
+}, s = (e, t = "PlitziFacade") => JSON.stringify({ imports: Object.keys(e).map((e) => ({
 	key: e,
-	bob: r(n(t(e), i))
+	bob: a(i(n(e), t))
 })).reduce((e, t) => ({
 	...e,
 	[t.key]: t.bob
-}), {}) }), o = (n, r = "PlitziFacade") => {
+}), {}) }), c = (e, r = "PlitziFacade") => {
 	if (typeof document > "u" || typeof window > "u") return;
-	let o = i(), s = e(n, Object.keys(o));
-	if (Object.keys(s).length === 0) return;
-	window[r] = Object.fromEntries(Object.entries(s).map(([e, n]) => [t(e), n]));
-	let c = a(s, r);
+	let i = o(), a = t(e, Object.keys(i));
+	if (Object.keys(a).length === 0) return;
+	Reflect.set(window, r, Object.fromEntries(Object.entries(a).map(([e, t]) => [n(e), t])));
+	let c = s(a, r);
 	if (!c) return;
 	let l = document.createElement("script");
 	l.type = "importmap", l.textContent = c, document.head.appendChild(l);
 };
 //#endregion
-export { o as default };
+export { c as default };

package/dist/helpers/index.mjs

@@ -16,6 +16,6 @@ import { INTERVAL_TRIGGER as k, MIN_INTERVAL_MS as A, intervalOf as j } from "./
 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 { ParamsFromURL as F, delay as I, emptyObject as L, getDisplayName as R, getKeyDecoded as z, getPathsFromObject 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 };
+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 getPathsFromObject, 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/utils.d.ts

@@ -2,7 +2,7 @@ import { FC } from 'react';
 export declare function getDisplayName<T = unknown>(WrappedComponent?: FC<T>): string;
 declare const emptyObject: {};
 export { emptyObject };
-export declare const getPathsFromObeject: (object?: {
+export declare const getPathsFromObject: (object?: {
     [key: string]: unknown;
 }, basePath?: string, glue?: string, skipArray?: boolean) => string[];
 export declare const makeId: (length: number, includeMayus?: boolean, includeNumbers?: boolean) => string;

package/dist/helpers/utils.mjs

@@ -58,4 +58,4 @@ var s = (e) => new Promise((t) => {
 	return t ? `rgba(${n},${r},${i},${t})` : `rgb(${n},${r},${i})`;
 };
 //#endregion
-export { o as ParamsFromURL, s as delay, n as emptyObject, t as getDisplayName, a as getKeyDecoded, r as getPathsFromObeject, l as hexToRGB, c as isInViewport, i as makeId };
+export { o as ParamsFromURL, s as delay, n as emptyObject, t as getDisplayName, a as getKeyDecoded, r as getPathsFromObject, l as hexToRGB, c as isInViewport, i as makeId };

package/dist/hooks/index.d.ts

@@ -1,7 +1,7 @@
 import { default as useFontHead } from './useFontHead';
 import { default as useNetwork } from './useNetwork';
-import { default as usePlitziServiceContext } from './usePlitziServiceContext';
+import { default as usePlitzi } from './usePlitzi';
 import { default as useStableValue } from './useStableValue';
 export * from './useNetwork';
-export * from './usePlitziServiceContext';
-export { useFontHead, useNetwork, usePlitziServiceContext, useStableValue };
+export * from './usePlitzi';
+export { useFontHead, useNetwork, usePlitzi, useStableValue };

package/dist/hooks/index.mjs

@@ -1,5 +1,5 @@
 import e from "./useStableValue.mjs";
 import t from "./useFontHead.mjs";
 import n from "./useNetwork.mjs";
-import r, { PlitziServiceContext as i, PlitziServiceProvider as a } from "./usePlitziServiceContext.mjs";
-export { i as PlitziServiceContext, a as PlitziServiceProvider, t as useFontHead, n as useNetwork, r as usePlitziServiceContext, e as useStableValue };
+import r, { PlitziContext as i, PlitziProvider as a } from "./usePlitzi.mjs";
+export { i as PlitziContext, a as PlitziProvider, t as useFontHead, n as useNetwork, r as usePlitzi, e as useStableValue };

package/dist/hooks/usePlitzi.d.ts

@@ -0,0 +1,32 @@
+import { ColorScheme } from '../types';
+import { ReactNode, RefObject } from 'react';
+/**
+ * What the host rendering a space — the builder, the SDK, a shadow-rooted widget — tells every element: whether it is
+ * being edited or looked at, its scheme, whether it is still hydrating, the window it paints in and the root it hangs
+ * from. Only what the host alone knows: a context of another package is imported from that package, never carried here.
+ */
+export type PlitziContextValue = {
+    settings: {
+        isHydrating?: boolean;
+        previewMode?: boolean;
+        environment?: string;
+        [key: string]: unknown;
+        /** Already resolved: an element paints in one of two schemes and has no use for the word `system`. */
+        theme: ColorScheme;
+    };
+    root: {
+        baseElementId: string;
+    };
+    utils: {
+        getWindow: () => Window | null;
+        rootRef: RefObject<HTMLElement | null>;
+    };
+};
+declare const PlitziContext: import('react').Context<PlitziContextValue>;
+declare const usePlitzi: () => PlitziContextValue;
+declare const PlitziProvider: (props: {
+    children?: ReactNode;
+    value: PlitziContextValue;
+}) => import('react').JSX.Element;
+export { PlitziProvider, PlitziContext };
+export default usePlitzi;

package/dist/hooks/{usePlitziServiceContext.mjs → usePlitzi.mjs}

@@ -1,9 +1,9 @@
 import { sharedContext as e } from "../helpers/sharedContext.mjs";
 import { use as t } from "react";
 import { jsx as n } from "react/jsx-runtime";
-var r = e("PlitziServiceContext", {}), i = () => {
+var r = e("PlitziContext", {}), i = () => {
 	let e = t(r);
-	if (e === void 0) throw Error("ServiceContext value is undefined. Make sure you use the PlitziServiceProvider before using the hook.");
+	if (e === void 0) throw Error("The Plitzi context is undefined. Render the element inside a PlitziProvider.");
 	return e;
 }, a = (e) => {
 	let { children: t, value: i } = e;
@@ -13,4 +13,4 @@ var r = e("PlitziServiceContext", {}), i = () => {
 	});
 };
 //#endregion
-export { r as PlitziServiceContext, a as PlitziServiceProvider, i as default };
+export { r as PlitziContext, a as PlitziProvider, i as default };