@plitzi/plitzi-builder 0.33.1 → 0.34.0

package/dist/modules/Fonts/fontsBaseUrl.d.ts

@@ -0,0 +1,9 @@
+import { Server } from '@plitzi/sdk-shared';
+/**
+ * Where the canvas and the panels address an uploaded face from.
+ *
+ * What the deployment declared, and otherwise the page server's own `/fonts` — which is where a self-hosted
+ * server keeps them. Guessing is confined to this one function so the canvas and the editor cannot disagree about
+ * which origin a font came from.
+ */
+export declare const fontsBaseUrl: (server: Pick<Server, "fontsBaseUrl" | "ssrServer">) => string | undefined;

package/dist/modules/Fonts/hooks/useFontCatalog.d.ts

@@ -0,0 +1,21 @@
+import { FontStyle } from '@plitzi/sdk-shared';
+export type FontCatalogEntry = {
+    family: string;
+    category: string;
+    weights: number[];
+    styles: FontStyle[];
+    subsets: string[];
+};
+/**
+ * The Google catalog, through this deployment's own endpoint.
+ *
+ * `unavailable` is a state of its own, not an empty result: a server with no API key cannot ask Google what exists,
+ * and telling somebody "no fonts matched" when nothing was searched would send them looking for a typo.
+ */
+declare const useFontCatalog: (query: string, enabled: boolean) => {
+    fonts: FontCatalogEntry[];
+    loading: boolean;
+    unavailable: boolean;
+    error: string | undefined;
+};
+export default useFontCatalog;

package/dist/modules/Fonts/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Fonts';
+export * from './Fonts';

package/dist/modules/Interactions/Interactions.d.ts

@@ -1,9 +1,10 @@
 import { Element } from '@plitzi/sdk-shared';
 export type InteractionsProps = {
     className?: string;
-    idRef?: string;
+    /** The element these interactions belong to, by the one name it answers to — the key the runtime wires them by. */
+    id?: string;
     interactions?: Element['definition']['interactions'];
     onChange?: (interactions: Element['definition']['interactions']) => void;
 };
-declare const Interactions: ({ className, idRef, interactions, onChange }: InteractionsProps) => import("react").JSX.Element;
+declare const Interactions: ({ className, id, interactions, onChange }: InteractionsProps) => import("react").JSX.Element;
 export default Interactions;

package/dist/modules/Interactions/components/Workflow/Workflow.d.ts

@@ -5,8 +5,12 @@ export type WorkflowProps = {
     callbackTitle?: string;
     nodeDefinitions?: InteractionCallback[];
     direction?: 'horizontal' | 'vertical';
+    /** What a new step is: `callback` for a page flow, `task` for a server action. */
+    stepType?: ElementInteraction['type'];
+    /** What a new TRIGGER starts as. A server action defaults to `call`; an element's flows have no obvious one. */
+    defaultTrigger?: string;
     dataSource?: Record<string, Source['meta']>;
     onChange?: (nodes: Record<string, ElementInteraction>) => void;
 };
-declare const Workflow: ({ nodes: nodesProp, triggerTitle, callbackTitle, nodeDefinitions, direction, dataSource, onChange }: WorkflowProps) => import("react").JSX.Element;
+declare const Workflow: ({ nodes: nodesProp, triggerTitle, callbackTitle, nodeDefinitions, direction, dataSource, stepType, defaultTrigger, onChange }: WorkflowProps) => import("react").JSX.Element;
 export default Workflow;

package/dist/modules/Interactions/components/Workflow/WorkflowContextProvider.d.ts

@@ -6,8 +6,10 @@ export type WorkflowContextProviderProps = {
     direction: 'horizontal' | 'vertical';
     dataSource?: Record<string, Source['meta']>;
     nodeDefinitions?: InteractionCallback[];
+    /** Default action for a new trigger, when the flow kind has an obvious one. */
+    defaultTrigger?: string;
     onChange: (nodes: Record<string, ElementInteraction>, debounced?: boolean) => void;
     setFlowId: (flowId: string) => void;
 };
-declare const WorkflowContextProvider: ({ children, nodes, direction, dataSource, nodeDefinitions, setFlowId, onChange }: WorkflowContextProviderProps) => import("react").JSX.Element;
+declare const WorkflowContextProvider: ({ children, nodes, direction, dataSource, nodeDefinitions, defaultTrigger, setFlowId, onChange }: WorkflowContextProviderProps) => import("react").JSX.Element;
 export default WorkflowContextProvider;

package/dist/modules/Interactions/components/Workflow/WorkflowFlow.d.ts

@@ -4,6 +4,8 @@ export type WorkflowFlowProps = {
     nodes?: Record<string, ElementInteraction>;
     triggerTitle?: string;
     callbackTitle?: string;
+    /** `callback` in a page flow; server-action steps are `task`. */
+    stepType?: ElementInteraction['type'];
 };
-declare const WorkflowFlow: ({ trigger, nodes, triggerTitle, callbackTitle }: WorkflowFlowProps) => import("react").JSX.Element;
+declare const WorkflowFlow: ({ trigger, nodes, triggerTitle, callbackTitle, stepType }: WorkflowFlowProps) => import("react").JSX.Element;
 export default WorkflowFlow;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/NodeHeader.d.ts

@@ -1,9 +1,9 @@
-import { ElementInteraction, InteractionCallback } from '@plitzi/sdk-shared';
+import { ElementInteraction, InteractionCallback, InteractionCallbackType } from '@plitzi/sdk-shared';
 export type NodeHeaderProps = {
     className?: string;
     id?: string;
     title?: string;
-    type?: 'trigger' | 'callback' | 'utility' | 'globalCallback';
+    type?: InteractionCallbackType;
     action?: string;
     elementId?: string;
     canDelete?: boolean;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/WorkflowNode.d.ts

@@ -1,9 +1,9 @@
 import { RuleGroup } from '@plitzi/plitzi-ui/QueryBuilder';
-import { InteractionCallbackParamValues } from '@plitzi/sdk-shared';
+import { InteractionCallbackParamValues, InteractionCallbackType } from '@plitzi/sdk-shared';
 export type WorkflowNodeProps = {
     id?: string;
     title?: string;
-    type?: 'trigger' | 'callback' | 'utility' | 'globalCallback';
+    type?: InteractionCallbackType;
     canDelete?: boolean;
     action?: string;
     elementId?: string;

package/dist/modules/Interactions/components/Workflow/helpers/nodeWarnings.d.ts

@@ -1,22 +1,19 @@
 import { ElementInteraction, InteractionCallback } from '@plitzi/sdk-shared';
 type NodeShape = Pick<ElementInteraction, 'type' | 'action' | 'elementId'>;
+/** `danger`: the step will not run. `warning`: it runs but is misconfigured. */
 export type WarningLevel = 'warning' | 'danger';
 export interface NodeWarning {
     level: WarningLevel;
     message: string;
 }
-/** FontAwesome classes (icon + color) per level — shared by the node and flow indicators so they stay consistent. */
+/** Icon + color per level, shared by the node and flow indicators. */
 export declare const WARNING_ICON: Record<WarningLevel, string>;
-/** The definition a stored node resolves to, matched by type, action and (for element callbacks) target — mirrors
- *  how WorkflowNode renders it. Undefined means the node points at nothing the runtime knows. */
+/** Definition a stored node resolves to; undefined means nothing known matches it. */
 export declare const findNodeDefinition: (node: NodeShape, nodeDefinitions: InteractionCallback[] | undefined) => InteractionCallback | undefined;
-/** The node targets an element that exists but has no idRef (a flagged, unreferenced definition), so the runtime
- *  cannot wire it — surfaced separately from the generic "not recognized" case. */
-export declare const isTargetUnreferenced: (node: Pick<ElementInteraction, "elementId">, nodeDefinitions: InteractionCallback[] | undefined) => boolean;
-export declare const getNodeWarnings: (node: NodeShape, nodeDefinition: InteractionCallback | undefined, targetUnreferenced: boolean) => NodeWarning[];
-/** The most severe level among a node's warnings (danger wins), or undefined when there are none. */
+/** Malformations of a stored node, checked against the definitions the editor renders from. */
+export declare const getNodeWarnings: (node: NodeShape, nodeDefinition: InteractionCallback | undefined) => NodeWarning[];
 export declare const worstLevel: (warnings: NodeWarning[]) => WarningLevel | undefined;
-/** Flow-level rollup: how many steps are malformed and the worst severity among them (drives the flow indicator). */
+/** Flow rollup for the flow indicator: malformed-step count and worst severity. */
 export declare const summarizeFlow: (nodes: Record<string, ElementInteraction>, nodeDefinitions: InteractionCallback[] | undefined) => {
     count: number;
     level: WarningLevel | undefined;

package/dist/modules/Segments/SegmentsReducer.d.ts

@@ -1,4 +1,4 @@
-import { DisplayMode, Element, SchemaVariable, Segment, Style, StyleItem, TagType, DropPosition, StyleVariableCategory, StyleVariableValue, StyleCategory, StyleState } from '@plitzi/sdk-shared';
+import { DisplayMode, Element, ReducerActionOrigin, SchemaVariable, Segment, Style, StyleItem, TagType, DropPosition, StyleVariableCategory, StyleVariableValue, StyleCategory, StyleState } from '@plitzi/sdk-shared';
 export declare const SegmentsActions: {
     readonly SEGMENTS_ADD: "SEGMENTS_ADD";
     readonly SEGMENTS_UPDATE: "SEGMENTS_UPDATE";
@@ -9,6 +9,7 @@ export declare const SegmentsActions: {
     readonly SEGMENTS_MOVE_ELEMENT: "SEGMENTS_MOVE_ELEMENT";
     readonly SEGMENTS_CLONE_ELEMENT: "SEGMENTS_CLONE_ELEMENT";
     readonly SEGMENTS_UPDATE_ELEMENT: "SEGMENTS_UPDATE_ELEMENT";
+    readonly SEGMENTS_RENAME_ELEMENT: "SEGMENTS_RENAME_ELEMENT";
     readonly SEGMENTS_UPDATE_ELEMENTS: "SEGMENTS_UPDATE_ELEMENTS";
     readonly SEGMENTS_SPACE_ADD_VARIABLE: "SEGMENTS_SPACE_ADD_VARIABLE";
     readonly SEGMENTS_SPACE_UPDATE_VARIABLE: "SEGMENTS_SPACE_UPDATE_VARIABLE";
@@ -24,10 +25,9 @@ export declare const SegmentsActions: {
     readonly SEGMENTS_STYLE_UPDATE_VARIABLE: "SEGMENTS_STYLE_UPDATE_VARIABLE";
     readonly SEGMENTS_STYLE_REMOVE_VARIABLE: "SEGMENTS_STYLE_REMOVE_VARIABLE";
 };
-type SegmentsReducerActionsBase = {
+type SegmentsReducerActionsBase = ReducerActionOrigin & {
     segmentId: string;
     segment?: Segment;
-    fromSubscriptions?: boolean;
 };
 export type SegmentsReducerActions = ({
     type: 'SEGMENTS_ADD';
@@ -60,6 +60,10 @@ export type SegmentsReducerActions = ({
 } & SegmentsReducerActionsBase) | ({
     type: 'SEGMENTS_UPDATE_ELEMENT';
     element: Element;
+} & SegmentsReducerActionsBase) | ({
+    type: 'SEGMENTS_RENAME_ELEMENT';
+    elementId: string;
+    id: string;
 } & SegmentsReducerActionsBase) | ({
     type: 'SEGMENTS_UPDATE_ELEMENTS';
     elements: Element[];

package/dist/modules/Space/helpers/elementsByRoot.d.ts

@@ -0,0 +1,19 @@
+import { Element } from '@plitzi/sdk-shared';
+/** One root of the schema — a page, or a layout several pages render inside — and how many elements it holds. */
+export interface RootElements {
+    page: string;
+    elements: number;
+}
+/**
+ * The element count, grouped by the page that holds it, off the LIVE schema.
+ *
+ * The same grouping the API answers for every other space, done here for the one being edited: those figures are
+ * whatever was last saved, and this one moves with the element someone just dropped — which is the whole reason the
+ * meter is in the editor rather than on a dashboard.
+ *
+ * It is a grouping, not a second measurement: it adds up to the element count exactly. Layouts are roots too and are
+ * listed as themselves rather than shared out over the pages that render inside them — their elements are authored
+ * once, and splitting them between pages would report a total that no page has.
+ */
+declare const elementsByRoot: (flat: Record<string, Element>) => RootElements[];
+export default elementsByRoot;

package/dist/modules/Space/helpers/elementsByRoot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/Space/hooks/useAccountUsage.d.ts

@@ -0,0 +1,60 @@
+/** One page of a space and what it spent of the allowance this period. */
+export interface UsagePage {
+    path: string;
+    views: number;
+}
+/** One page of a space and how many elements it holds — a grouping of `elements`, so it adds up to it exactly. */
+export interface UsagePageElements {
+    page: string;
+    elements: number;
+}
+export interface UsageSpace {
+    id: number;
+    name: string;
+    /** Page views this space spent this period — the same window the ceilings are judged over. */
+    views: number;
+    elements: number;
+    /**
+     * What the page rows add up to, which is not the same as `views`: an RSC refresh and a server action are charged to
+     * the space and answered at their own endpoints, so they belong to no page.
+     */
+    pagesTotal: number;
+    pages: UsagePage[];
+    elementsByPage: UsagePageElements[];
+    /** This space's share of the account total, as a percentage — what the bar beside it is drawn from. */
+    viewsShare: number;
+    elementsShare: number;
+    /** More than one page, so its per-page rows say something its total does not. */
+    multiPage: boolean;
+}
+export interface UsageKind {
+    kind: string;
+    label: string;
+    origin: number;
+    cached: number;
+    weight: number;
+    cachedWeight: number;
+}
+export interface AccountUsage {
+    planName: string;
+    periodEndsAt: string;
+    usageByKind: UsageKind[];
+    spaces: UsageSpace[];
+}
+/**
+ * Where the account's allowance actually went — by space, and by page inside each one.
+ *
+ * The ceilings themselves come over GraphQL (`SpaceQuota`) and are what the header meter is made of: this space, this
+ * account, and the two numbers each. This is the other half of the answer, and it is only worth a request when
+ * somebody asks the question, which is why `enabled` exists — nothing is fetched until the panel is opened.
+ *
+ * It reads the API role rather than the GraphQL one because that is where the endpoint lives and where the same
+ * figures are already served to the dashboard; the builder's user token rides in the header every other call uses.
+ * Fetched once per panel: these are period totals, not something that moves while somebody reads them.
+ */
+declare const useAccountUsage: (enabled: boolean) => {
+    usage: AccountUsage | undefined;
+    error: string | undefined;
+    loading: boolean;
+};
+export default useAccountUsage;

package/dist/modules/Space/hooks/useSpaceQuota.d.ts

@@ -0,0 +1,52 @@
+import { TSpaceQuota } from '@plitzi/sdk-shared';
+/** A quota figure as it is shown: whole units, grouped. */
+export declare const format: (value: number) => string;
+/** How close one ceiling is, as the three states a UI treats differently. */
+export type QuotaLevel = 'ok' | 'near' | 'over';
+export interface QuotaReading {
+    /** Stable across renders, so a warning can be shown once rather than on every keystroke. */
+    id: string;
+    scope: 'space' | 'account';
+    metric: 'elements' | 'views';
+    label: string;
+    used: number;
+    /** The ceiling. 0 when the plan does not enforce one — see `unlimited`. */
+    quota: number;
+    /**
+     * There is no ceiling on this plane.
+     *
+     * Kept as a reading rather than dropped, because the figure is still worth showing: someone on an unlimited plan
+     * still wants to know their space holds 588 elements. What `unlimited` decides is that it can never be `near` or
+     * `over`, so it never colours the meter and never raises a warning.
+     */
+    unlimited: boolean;
+    percent: number | null;
+    level: QuotaLevel;
+}
+export declare const readingsFor: (quota: TSpaceQuota, liveSpaceElements: number) => QuotaReading[];
+/**
+ * Whether this plan has an allowance that comes back — the only case where a reset date says anything.
+ *
+ * The counters roll with the period on every plan, Lifetime included, so a date is always available; that is not the
+ * same as it being worth showing. With no ceiling on page views there is nothing to get back, and "resets 1 Sep"
+ * next to "Unlimited" reads as a limit that is not there. Elements never decide it: a schema is a stock, not a
+ * flow, and it does not empty when the month does.
+ */
+export declare const refillsPeriodically: (readings: QuotaReading[]) => boolean;
+/**
+ * The plan ceilings this space is edited against, with the element counts corrected to the live schema.
+ *
+ * Element caps are the ones reached WHILE editing — someone drops a component and crosses one — so they are counted
+ * off the store rather than off the server, and move as the page does. Page views are spent by visitors, so they come
+ * from the server and are refreshed on a timer.
+ */
+declare const useSpaceQuota: () => {
+    quota: TSpaceQuota | undefined;
+    readings: QuotaReading[];
+    enforced: QuotaReading[];
+    worst: QuotaReading | undefined;
+    featured: QuotaReading | undefined;
+    liveElements: number;
+    error: Error | undefined;
+};
+export default useSpaceQuota;

package/dist/modules/Space/hooks/useSpaceQuota.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/Variables/components/UrlParams/UrlParams.d.ts

@@ -0,0 +1,17 @@
+export type UrlParamsProps = {
+    className?: string;
+};
+/**
+ * The URL the page is being tried on.
+ *
+ * The editor's own address says nothing about the page inside it, so a route that takes a `:slug`, a variable that
+ * switches on `?plan=pro` or a binding that reads the hostname had no way to be exercised without publishing. What
+ * is set here is laid over the browser's own values in `NavigationProvider`, which is the one place that publishes
+ * `navigation.*` — so the canvas, the preview pane, the variable list and every server-driven element resolve
+ * against the same tested URL rather than each against its own idea of one.
+ *
+ * The route params of the page being edited are listed even when empty, because the page declaring one is the fact
+ * an author needs to see; a query param has no such declaration, so those are added by hand.
+ */
+declare const UrlParams: ({ className }: UrlParamsProps) => import("react").JSX.Element;
+export default UrlParams;

package/dist/modules/Variables/components/UrlParams/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './UrlParams';
+export * from './UrlParams';

package/dist/package.json.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
   "name": "@plitzi/plitzi-builder",
-  "version": "0.33.1",
+  "version": "0.34.0",
   "homepage": "./",
   "license": "AGPL-3.0",
   "files": [
@@ -26,11 +26,11 @@ declare const _default: {
     "./plitzi-builder-dev-vendor.js.map": "./dist/plitzi-builder-dev-vendor.js.map"
   },
   "dependencies": {
-    "@apollo/client": "^4.2.11",
+    "@apollo/client": "^4.3.0",
     "@fortawesome/fontawesome-free": "^7.3.1",
-    "@plitzi/nexus": "^1.1.0",
+    "@plitzi/nexus": "^1.1.4",
     "@plitzi/plitzi-sdk": "workspace:*",
-    "@plitzi/plitzi-ui": "^1.6.19",
+    "@plitzi/plitzi-ui": "^1.6.21",
     "@plitzi/sdk-auth": "workspace:*",
     "@plitzi/sdk-dev-tools": "workspace:*",
     "@plitzi/sdk-elements": "workspace:*",
@@ -42,64 +42,63 @@ declare const _default: {
     "@plitzi/sdk-shared": "workspace:*",
     "@plitzi/sdk-style": "workspace:*",
     "@plitzi/sdk-variables": "workspace:*",
-    "@tanstack/react-virtual": "^3.14.9",
-    "@xyflow/react": "^12.11.3",
+    "@tanstack/react-virtual": "^3.14.12",
+    "@xyflow/react": "^12.11.6",
     "apollo-upload-client": "^20.0.0",
     "clsx": "^2.1.1",
     "graphql": "^17.0.2",
     "graphql-ws": "^6.2.1",
-    "immer": "^11.1.16",
-    "jszip": "^3.10.1",
-    "react-hook-form": "^7.85.0",
-    "react-router-dom": "^7.18.2",
+    "immer": "^11.1.18",
+    "jszip": "^3.10.2",
+    "react-hook-form": "^7.88.0",
+    "react-router-dom": "^7.18.3",
     "swr": "^2.5.1",
-    "uuid": "^14.0.1",
-    "zod": "^4.4.3"
+    "uuid": "^14.0.2",
+    "zod": "^4.6.4"
   },
   "peerDependencies": {
     "react": "^19",
     "react-dom": "^19"
   },
   "devDependencies": {
-    "@babel/compat-data": "^8.0.0",
-    "@babel/core": "^8.0.1",
+    "@babel/compat-data": "^8.0.5",
+    "@babel/core": "^8.0.5",
     "@babel/helper-builder-react-jsx-experimental": "^7.12.11",
     "@babel/helper-validator-identifier": "^8.0.4",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/plugin-transform-private-methods": "^8.0.1",
     "@babel/plugin-transform-runtime": "^8.0.1",
     "@babel/polyfill": "^7.12.1",
-    "@babel/preset-env": "^8.0.2",
+    "@babel/preset-env": "^8.0.5",
     "@babel/preset-react": "^8.0.1",
     "@tailwindcss/postcss": "^4.3.3",
-    "css-loader": "^7.1.4",
-    "cypress": "15.20.1",
+    "css-loader": "^7.1.5",
     "eslint": "^9.39.5",
     "eslint-plugin-import": "^2.32.0",
-    "flow-bin": "^0.327.0",
-    "postcss": "^8.5.26",
+    "flow-bin": "^0.331.0",
+    "postcss": "^8.5.28",
     "postcss-loader": "^8.2.1",
     "postcss-scss": "^4.0.9",
     "prettier": "^3.9.6",
     "prop-types": "^15.8.1",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "react-refresh": "^0.18.0",
-    "react-test-renderer": "^19.2.8",
-    "sass": "^1.102.0",
-    "sass-embedded": "^1.102.0",
-    "sass-loader": "^17.0.0",
-    "stylelint": "^17.14.1",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "react-refresh": "^0.19.0",
+    "react-test-renderer": "^19.3.0",
+    "sass": "^1.104.1",
+    "sass-embedded": "^1.104.1",
+    "sass-loader": "^17.0.1",
+    "stylelint": "^17.15.0",
     "stylelint-order": "^8.1.1",
     "stylelint-scss": "^7.2.0",
-    "terser": "^5.50.0",
+    "terser": "^5.51.2",
     "typescript": "^6.0.3",
-    "vite": "^8.2.1",
-    "vite-plugin-dts": "^5.0.3",
+    "vite": "^8.3.0",
+    "vite-plugin-dts": "^5.1.0",
     "vite-plugin-ejs": "^2.0.0",
     "vite-plugin-mkcert": "^2.1.0",
     "vite-plugin-react": "^4.0.1",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "start": "vite dev --mode development",