@plitzi/sdk-shared 0.38.10 → 0.38.12

package/dist/style/styleTarget.mjs

@@ -1,35 +1,36 @@
-import { canonicalCondition as e } from "./styleConditions.mjs";
-import { isStylePseudo as t } from "./stylePseudos.mjs";
-import { isParentAncestor as n } from "./styleStates.mjs";
+import { isRecord as e } from "../helpers/isRecord.mjs";
+import { canonicalCondition as t } from "./styleConditions.mjs";
+import { isStylePseudo as n } from "./stylePseudos.mjs";
+import { isParentAncestor as r } from "./styleStates.mjs";
 //#region src/style/styleTarget.ts
-var r = (e) => {
+var i = (e) => {
 	let t = [];
 	return e.styleAncestor ? t.push("ancestors", e.styleAncestor) : e.styleCondition && t.push("conditions", e.styleCondition), e.styleVariant && t.push("variants", e.styleVariant), e.stylePseudo && t.push("pseudos", e.stylePseudo), t.push(...e.styleState ? ["states", e.styleState] : ["default"]), t;
-}, i = (r) => {
-	if (r.styleAncestor && r.styleCondition) return "an ancestor condition cannot also be under a condition";
-	if (r.styleAncestor && r.stylePseudo) return "a pseudo-element has no ancestor conditions of its own";
-	if (r.styleCondition && r.styleVariant) return "a condition holds the class’s own rules, not its variants’";
-	if (r.styleCondition && e(r.styleCondition) !== r.styleCondition) return `"${r.styleCondition}" is not a condition`;
-	if (r.stylePseudo && !t(r.stylePseudo)) return `"${String(r.stylePseudo)}" is not a pseudo-element`;
-	if (r.styleAncestor && n(r.styleAncestor) && r.styleVariant) return "the element around it is named by its state, never by a variant";
-}, a = (e) => typeof e == "object" && !!e && !Array.isArray(e), o = (e, t) => {
-	let n = e;
-	for (let e of t) {
-		if (!a(n) || !Object.hasOwn(n, e)) return;
-		n = n[e];
+}, a = (e) => {
+	if (e.styleAncestor && e.styleCondition) return "an ancestor condition cannot also be under a condition";
+	if (e.styleAncestor && e.stylePseudo) return "a pseudo-element has no ancestor conditions of its own";
+	if (e.styleCondition && e.styleVariant) return "a condition holds the class’s own rules, not its variants’";
+	if (e.styleCondition && t(e.styleCondition) !== e.styleCondition) return `"${e.styleCondition}" is not a condition`;
+	if (e.stylePseudo && !n(e.stylePseudo)) return `"${String(e.stylePseudo)}" is not a pseudo-element`;
+	if (e.styleAncestor && r(e.styleAncestor) && e.styleVariant) return "the element around it is named by its state, never by a variant";
+}, o = (t, n) => {
+	let r = t;
+	for (let t of n) {
+		if (!e(r) || !Object.hasOwn(r, t)) return;
+		r = r[t];
 	}
-	return n;
-}, s = (e, t, n) => {
-	let r = e;
-	t.slice(0, -1).forEach((e) => {
-		let t = r[e], n = a(t) ? t : {};
-		r[e] = n, r = n;
+	return r;
+}, s = (t, n, r) => {
+	let i = t;
+	n.slice(0, -1).forEach((t) => {
+		let n = i[t], r = e(n) ? n : {};
+		i[t] = r, i = r;
 	});
-	let i = t.at(-1);
-	i !== void 0 && (r[i] = n);
-}, c = (e) => a(e) && Object.values(e).every((e) => typeof e == "string" || typeof e == "number"), l = (e, t) => {
-	let n = o(e, r(t));
+	let a = n.at(-1);
+	a !== void 0 && (i[a] = r);
+}, c = (t) => e(t) && Object.values(t).every((e) => typeof e == "string" || typeof e == "number"), l = (e, t) => {
+	let n = o(e, i(t));
 	return c(n) ? n : void 0;
 };
 //#endregion
-export { c as isStyleRules, s as setAtKeys, r as styleTargetKeys, i as styleTargetProblem, l as styleTargetRules, o as valueAtKeys };
+export { c as isStyleRules, s as setAtKeys, i as styleTargetKeys, a as styleTargetProblem, l as styleTargetRules, o as valueAtKeys };

package/dist/style/useElementSize.d.ts

@@ -0,0 +1,16 @@
+import { RefObject } from 'react';
+export type ElementSize = {
+    width: number;
+    height: number;
+};
+/**
+ * The size an element is drawn at — a plugin's own box, which a sidebar, a panel or a split screen makes narrower than
+ * the window — kept up to date as it changes. What `useDisplayMode` cannot say: a tablet held upright is `mobile` by
+ * the window's breakpoints, and a week of seven columns still fits the 744 px the plugin has.
+ *
+ * `undefined` until it is measured: on the server, and in the browser's first render, so the page the server sent and
+ * the one that hydrates it are the same. Decide from a fallback until then — the breakpoint's guess:
+ * `const days = (size?.width ?? (useDisplayMode() === 'mobile' ? 390 : 1024)) >= 640 ? 7 : 3`.
+ */
+declare const useElementSize: (ref: RefObject<HTMLElement | null>) => ElementSize | undefined;
+export default useElementSize;

package/dist/style/useElementSize.mjs

@@ -0,0 +1,20 @@
+import { useEffect as e, useState as t } from "react";
+//#region src/style/useElementSize.ts
+var n = (n) => {
+	let [r, i] = t(void 0);
+	return e(() => {
+		let e = n.current;
+		if (!e || typeof ResizeObserver > "u") return;
+		let t = (e, t) => i((n) => n?.width === e && n.height === t ? n : {
+			width: e,
+			height: t
+		}), r = e.getBoundingClientRect();
+		t(r.width, r.height);
+		let a = new ResizeObserver((e) => {
+			e.slice(-1).forEach((e) => t(e.contentRect.width, e.contentRect.height));
+		});
+		return a.observe(e), () => a.disconnect();
+	}, [n]), r;
+};
+//#endregion
+export { n as default };

package/dist/types/ActionTypes.d.ts

@@ -70,10 +70,11 @@ export type ActionWebhookVerification = {
  * The ways into an action, as the `action` of a trigger STEP rather than a list beside the flow.
  *
  * `call` — a client flow through the action endpoint. `webhook` — an inbound request, public by construction.
- * `schedule` — a cron tick. `render` — a `runtime: 'server'` element naming this action. `custom` — a trigger the
- * deployment mounted itself.
+ * `schedule` — a cron tick. `later` — a run another one set to start N seconds from then (`ctx.later`, `flow.later`):
+ * a turn that runs out, a bot's move, a hold that lapses. `render` — a `runtime: 'server'` element naming this action.
+ * `custom` — a trigger the deployment mounted itself.
  */
-export type ActionTriggerType = 'call' | 'webhook' | 'schedule' | 'render' | 'custom';
+export type ActionTriggerType = 'call' | 'webhook' | 'schedule' | 'later' | 'render' | 'custom';
 /**
  * What a trigger step carries, in its `params`.
  *
@@ -551,6 +552,11 @@ export type ActionJobInput = {
     maxAttempts: number;
     /** Fires that went by unclaimed before this one. Shown to an operator; never acted on. */
     missed?: number;
+    /**
+     * What a run set to run later (`trigger: 'later'`) was named by: setting it again under the same name replaces the
+     * one still waiting, and cancelling it by name drops it.
+     */
+    key?: string;
 };
 /** One unit of work the queue is holding, as an operator sees it. */
 export type ActionJob = ActionJobInput & {
@@ -692,4 +698,14 @@ export type ActionJobQueue = {
     requeue: (spaceIds: number[], jobId: string) => Promise<boolean>;
     /** An operator stopping a job: dropped if it is waiting, aborted at its next step if it is running. */
     cancel: (spaceIds: number[], jobId: string) => Promise<boolean>;
+    /**
+     * Drops the space's jobs waiting under `key` (`cancelled`), and answers how many. With `olderThan`, only the ones
+     * enqueued before that job — created earlier, or at the same instant with a smaller id — so of two set at once the
+     * newer is the one left, on every replica. A running one is left: it is usually the run that set the next.
+     */
+    cancelPending: (params: {
+        spaceId: number;
+        key: string;
+        olderThan?: string;
+    }) => Promise<number>;
 };

package/dist/types/DataSourceTypes.d.ts

@@ -20,13 +20,18 @@ export type DataSourceUtilityParams<TParams = string | boolean | number> = Recor
 }>;
 export type DataSourceUtilityParamsValue<T = string | boolean | number> = Record<keyof DataSourceUtility<T>['params'], T>;
 export type DataSourceUtilityParamType = 'text' | 'select' | 'textarea' | 'checkbox' | 'codemirror-text';
-export type DataSourceUtility<TSource = any, TSourceReturn = string | boolean | number, TParams = string | boolean | number> = {
+/**
+ * A step a binding's value goes through on its way to an attribute. It receives whatever the binding resolved to — or
+ * the step before it answered — and a value it has no use for goes on untouched, so both ends are `unknown` unless one
+ * says more.
+ */
+export type DataSourceUtility<TSource = unknown, TSourceReturn = unknown, TParams = string | boolean | number> = {
     action: string;
     title: string;
     type: 'utility' | 'unknown';
     params: DataSourceUtilityParams<TParams>;
     preview: Record<string, string>;
-    callback: (source: TSource, params: DataSourceUtilityParamsValue<TParams>, element: Partial<Element>, dataSources?: Record<string, any>) => TSourceReturn;
+    callback: (source: TSource, params: DataSourceUtilityParamsValue<TParams>, element: Partial<Element>, dataSources?: Record<string, unknown>) => TSourceReturn;
 };
 export type SourceField = {
     path: string;

package/dist/types/EventBridgeTypes.d.ts

@@ -1,4 +1,5 @@
-export type EventBridgeContextValue<T = any> = {
+/** What sdk-event-bridge's context holds: its bridge, whose class is that package's own. */
+export type EventBridgeContextValue<T> = {
     eventBridge: T;
 };
 export type EventBridgeModule = 'main' | 'builder' | 'snippet' | 'interaction' | 'element';

package/dist/types/InteractionTypes.d.ts

@@ -30,17 +30,28 @@ export type InteractionCallbackParam<T extends Record<string, unknown> = Record<
      * space's credentials of that kind to pick from, rather than a text box somebody has to type an identifier into.
      */
     credentialProvider?: SpaceCredentialProvider;
-} & ({
+    /**
+     * A space's task refuses to run without it — empty, or only spaces — saying so with the param's `label`, before its
+     * code runs: what a task otherwise checked by hand in its first lines.
+     */
+    required?: boolean;
+} & 
+/** Handed to a task as text, whatever was written or bound — a number as its digits — at most `maxLength` long. */
+({
     type: 'text';
     defaultValue?: string | number;
+    maxLength?: number;
 }
-/** Written as text — a number or a template — and handed to the callback as a number. */
+/** Written as text — a number or a template — and handed to the callback as a number, within `min` and `max`. */
  | {
     type: 'number';
     defaultValue?: number;
+    min?: number;
+    max?: number;
 } | {
     type: 'textarea';
     defaultValue?: string | number;
+    maxLength?: number;
 } | {
     type: 'codemirror-text';
     defaultValue?: string;
@@ -133,8 +144,35 @@ export type Subscriptor<T extends Record<string, unknown> = Record<string, unkno
     id: string;
     triggers: Record<string, Trigger<T>>;
 };
-export type InteractionsContextValue<TManager = any> = {
-    interactionsManager: TManager;
+/**
+ * The interactions manager as everything outside sdk-interactions reaches it — through its context. Declared here, where
+ * every package can name it, and implemented by sdk-interactions' `InteractionsManager`, which the compiler holds to it.
+ *
+ * Methods, not function-valued fields: a manager's children are managers of its own class, which only this way can
+ * stand for the interface.
+ */
+export interface InteractionsManagerApi {
+    /** The page's id and its route and query params: what a flow reads as `navigation`. */
+    interactionsData: Record<string, string | number | boolean>;
+    /**
+     * Fires `eventName` on the element `subscriptorId`: the flows it starts, with `params` for them to read — what each
+     * answered, or nothing when there is no element to fire on.
+     */
+    interactionTrigger(subscriptorId: string | undefined, eventName: string, params?: Record<string, unknown>): Promise<unknown[]> | undefined;
+    subscribe<TParams extends Record<string, unknown> = Record<string, unknown>>(id: string, interactions?: Record<string, ElementInteraction>, triggers?: Record<string, InteractionCallback<TParams>>, callbacks?: Record<string, InteractionCallback<TParams>>, getAdditionalParams?: Subscriptor<TParams>['getAdditionalParams']): boolean;
+    update<TParams extends Record<string, unknown> = Record<string, unknown>>(id: string, interactions?: Record<string, ElementInteraction>, triggers?: Record<string, InteractionCallback<TParams>>, callbacks?: Record<string, InteractionCallback<TParams>>, getAdditionalParams?: Subscriptor<TParams>['getAdditionalParams']): boolean;
+    unsubscribe(id: string): boolean;
+    getSubscriptor(subscriptorId: string): Subscriptor | undefined;
+    /** Every callback an element answers, by element and action — the step picker's list. */
+    getCallbacksAvailables(): Record<string, Record<string, InteractionCallback>>;
+    /** A manager for a replica — a list's row — whose route and query params are its own. */
+    createChildManager(routeParams?: Record<string, string>, queryParams?: Record<string, string>): InteractionsManagerApi;
+    removeChildManager(childManager: InteractionsManagerApi): void;
+    /** Called with the time of each change to what is subscribed; answers how to stop. */
+    onUpdate(listener: (timestamp: number) => void): () => void;
+}
+export type InteractionsContextValue = {
+    interactionsManager: InteractionsManagerApi;
     useInteractions: <T extends Record<string, unknown> = Record<string, unknown>>(props: {
         id?: string;
         interactions?: Record<string, ElementInteraction>;

package/dist/types/RealtimeTypes.d.ts

@@ -50,9 +50,22 @@ export type RealtimeMessage = RealtimeSender & {
     data: unknown;
     /** Server time, in milliseconds. */
     at: number;
+    /**
+     * The sender asked to hear it too ({@link RealtimePublishOptions}): it reaches the page that sent it as well, which
+     * knows it for its own by `from` — its channel's `me`. Without it, a page never hears what it sent.
+     */
+    echo?: true;
+};
+/** What a page asks of a publish beyond the message itself. */
+export type RealtimePublishOptions = {
+    /**
+     * Hear it too, once the server took it — a reaction, a chat line: what the sender shows the moment it sends. Off by
+     * default, so what moves at the speed of a cursor is not drawn twice.
+     */
+    echo?: boolean;
 };
 /** What a page sends to publish: the secret its connection was given, and the message. */
-export type RealtimePublishRequest = {
+export type RealtimePublishRequest = RealtimePublishOptions & {
     token: string;
     topic: string;
     type: string;

package/dist/types/ServerTypes.d.ts

@@ -1185,7 +1185,12 @@ export type SSRContext = {
     rscParams?: Record<string, string>;
 };
 export type SSRServer = {
-    listen: (port: number, host?: string) => void;
+    /**
+     * Binds the port. Resolves once it takes connections — in a fleet, once the first worker does — so what says "ready"
+     * (a log line, a file a tool reads, a test's first request) says it after, never before. A port it could not take
+     * ends the process, or goes to `onListenError`: the promise is then never resolved.
+     */
+    listen: (port: number, host?: string) => Promise<void>;
     close: () => Promise<void>;
     readonly cache: CacheManager | null;
     readonly plugins: PluginRegistry;

package/dist/websockets/RTCodec.d.ts

@@ -112,7 +112,12 @@ export type RTMessageManagedServer = {
     type: RTEvent.COLLABORATOR_DISCONNECTED;
     payload: SubscriptionCollaborator;
 };
-export type RTCallback = (...args: any[]) => void;
+/** What a message of one event carries, as the server sends it. */
+export type RTPayload<E extends RTEvent> = Extract<RTMessageManagedServer, {
+    type: E;
+}>['payload'];
+/** A listener for one realtime event, handed what that event carries. */
+export type RTCallback<E extends RTEvent = RTEvent> = (payload: RTPayload<E>) => void;
 export type RTMessage<T = unknown> = {
     type: RTEvent;
     payload: T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-shared",
-  "version": "0.38.10",
+  "version": "0.38.12",
   "license": "AGPL-3.0",
   "files": [
     "dist",
@@ -571,9 +571,9 @@
       "types": "./dist/hooks/useNetwork.d.ts",
       "import": "./dist/hooks/useNetwork.mjs"
     },
-    "./hooks/usePlitziServiceContext": {
-      "types": "./dist/hooks/usePlitziServiceContext.d.ts",
-      "import": "./dist/hooks/usePlitziServiceContext.mjs"
+    "./hooks/usePlitzi": {
+      "types": "./dist/hooks/usePlitzi.d.ts",
+      "import": "./dist/hooks/usePlitzi.mjs"
     },
     "./hooks/useStableValue": {
       "types": "./dist/hooks/useStableValue.d.ts",
@@ -1099,6 +1099,10 @@
       "types": "./dist/network/spaceEvents.d.ts",
       "import": "./dist/network/spaceEvents.mjs"
     },
+    "./plugins/PluginsContext": {
+      "types": "./dist/plugins/PluginsContext.d.ts",
+      "import": "./dist/plugins/PluginsContext.mjs"
+    },
     "./plugins/bundle": {
       "types": "./dist/plugins/bundle.d.ts",
       "import": "./dist/plugins/bundle.mjs"
@@ -1431,6 +1435,10 @@
       "types": "./dist/style/useDisplayMode.d.ts",
       "import": "./dist/style/useDisplayMode.mjs"
     },
+    "./style/useElementSize": {
+      "types": "./dist/style/useElementSize.d.ts",
+      "import": "./dist/style/useElementSize.mjs"
+    },
     "./theme": {
       "types": "./dist/theme/index.d.ts",
       "import": "./dist/theme/index.mjs"
@@ -1576,7 +1584,7 @@
   },
   "dependencies": {
     "@plitzi/nexus": "^1.4.0",
-    "@plitzi/plitzi-ui": "^1.6.32",
+    "@plitzi/plitzi-ui": "^1.6.33",
     "date-fns": "^4.4.0",
     "immer": "^11.1.21",
     "zod": "^4.6.5"

package/dist/hooks/usePlitziServiceContext.d.ts

@@ -1,38 +0,0 @@
-import { BuilderContextValue } from '../builder';
-import { NetworkContextValue } from '../network';
-import { ComponentContextValue, EventBridgeContextValue, InteractionsContextValue, PluginsContextValue, ColorScheme } from '../types';
-import { Context, ReactNode, RefObject } from 'react';
-export type PlitziServiceContextValue<TEventBridge = any, TInteractions = any> = {
-    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>;
-    };
-    customContexts: Record<string, Context<any>>;
-    contexts: {
-        ComponentContext: Context<ComponentContextValue>;
-        EventBridgeContext: Context<EventBridgeContextValue<TEventBridge>>;
-        PluginsContext: Context<PluginsContextValue>;
-        InteractionsContext: Context<InteractionsContextValue<TInteractions>>;
-        NetworkContext: Context<NetworkContextValue>;
-        BuilderContext?: Context<BuilderContextValue>;
-    };
-};
-declare const PlitziServiceContext: Context<PlitziServiceContextValue<any, any>>;
-declare const usePlitziServiceContext: <TEventBridge = any, TInteractions = any>() => PlitziServiceContextValue<TEventBridge, TInteractions>;
-declare const PlitziServiceProvider: (props: {
-    children?: ReactNode;
-    value: PlitziServiceContextValue;
-}) => import('react').JSX.Element;
-export { PlitziServiceProvider, PlitziServiceContext };
-export default usePlitziServiceContext;