@mosetta/react 0.0.12 → 0.0.14

package/AUTHORING.md

@@ -171,6 +171,35 @@ const booking = useServerAction({ token: bookToken, start: EServerActionStart.ST
   never in the code or the environment. The server side of a tile is named like its component
   (`booking.server.ts` beside `booking.component.tsx`).
 
+### The block a call comes from
+
+The input is whatever the browser sent — anybody can send anything. What the site's author set on
+the block (the hours a booking form offers, the address a contact form writes to) is given to the
+action separately, read by the host from the page itself: `block` beside `input`, in `action` and in
+`authorize`.
+
+```ts
+async action({ input, block }: IServerActionPayload<IBookingInput>) {
+  const hours = (block?.settings.hours ?? []) as string[];
+  if (!hours.includes(input.slot)) return { ok: false }; // not a time this form offers
+  // … write the booking
+  return { ok: true };
+}
+```
+
+- `block` is `{ page, node, reference, settings, draft }`: the page's name, the block's id on it, the
+  block's tile, its settings as stored, and whether it was read from a draft. A translated text in
+  the settings stays a reference (`{ $ref: … }`), as the page stores it.
+- The component side does nothing for it: `useServerAction` says which block on which page calls.
+  The host finds that block on the page as published; in a draft's preview, in the draft — for the
+  site's editors only, everybody else gets the published page.
+- `block` is `null` when the call comes from no page, when the block is not on the page as published
+  (a stale tab, a new block not published yet), or when it is not a tile of this palette at the
+  action's own version. An action that needs the block's settings refuses then: never fall back to
+  something the input says.
+- Inside a prefab, the block's id is `<prefab's id on the page>/<id in the prefab>` and its settings
+  are as rendered, the instance's fields filled. A block inside a library's prefab is not read.
+
 ## Rules of a project's palette on the platform
 
 - Its brand is the project's own; it holds the project's tiles (and the packages they import), every
@@ -181,3 +210,8 @@ const booking = useServerAction({ token: bookToken, start: EServerActionStart.ST
   error comes back as the checker's line.
 - Every release is the next patch version. Pages keep the version they name; update a block on a
   page to take the new one.
+- A **draft** is a build that is no release: no version spent, the site unchanged. Any page of the
+  site opened with `?previewOverride=<brand>.<block>:<draft>` shows that block from the draft
+  (`<brand>:<draft>` — every block of it), whatever version the page names — its server side
+  included — for the site's editors, or for anybody given a shared link. Release once it is right.
+  The palette keeps its last 10 drafts.

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @mosetta/react
 
+## 0.0.14
+
+### Patch Changes
+
+- Updated dependencies
+  - @mosetta/core@0.0.14
+  - @mosetta/server@0.0.14
+  - @mosetta/di@0.0.14
+  - @mosetta/runtime@0.0.14
+  - @mosetta/server-action@0.0.14
+
+## 0.0.13
+
+### Patch Changes
+
+- A server action learns the block it is called from: `block` — the page, the node, the tile and its
+  settings as the page stores them — beside `input`, in `action` and in `authorize` (and as
+  `BLOCK_TOKEN`). The browser only says which block on which page calls; the runner reads that block
+  off the published page itself (a draft's, for the site's editors), so the settings are the site
+  author's and can be trusted. `useServerAction` sends where the call comes from without the
+  component doing anything.
+- Updated dependencies
+  - @mosetta/server-action@0.0.13
+  - @mosetta/server@0.0.13
+  - @mosetta/core@0.0.13
+  - @mosetta/di@0.0.13
+  - @mosetta/runtime@0.0.13
+
 ## 0.0.12
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosetta/react",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "React binding of the mosetta protocol: side definers, hooks, blueprint renderer, DI adapter, server-action hook, startAndMount. Subpath exports only (no barrel) — each entry ships as its own package tile; ./context is the internal state-singleton entry the others re-export from.",
   "license": "MIT",
   "type": "commonjs",
@@ -13,11 +13,11 @@
   "dependencies": {
     "react": "*",
     "react-dom": "*",
-    "@mosetta/core": "0.0.12",
-    "@mosetta/di": "0.0.12",
-    "@mosetta/runtime": "0.0.12",
-    "@mosetta/server": "0.0.12",
-    "@mosetta/server-action": "0.0.12"
+    "@mosetta/core": "0.0.14",
+    "@mosetta/di": "0.0.14",
+    "@mosetta/runtime": "0.0.14",
+    "@mosetta/server-action": "0.0.14",
+    "@mosetta/server": "0.0.14"
   },
   "devDependencies": {
     "@types/react": "*",

package/src/hooks/NodeContext.tsx

@@ -91,6 +91,9 @@ export const ProvideNode = NodeContext.Provide;
 
 export const useNode = NodeContext.use;
 
+/** the node a component renders in, or null outside a page's tree (a hosted mount, a tool) */
+export const useNodeOptional = NodeContext.useOptional;
+
 function useNodeState(): INodeState {
   const { id } = useNode();
   const di = useDi(DI_CONTAINER_TOKEN);

package/src/serverAction.ts

@@ -19,8 +19,10 @@
 // conditional hooks (branches are value-level), no module-level shared state. Opt-in suspense throws
 // the waiter promise — the legacy protocol both runtimes (and preact's renderToStringAsync) support.
 import { useCallback, useState, useSyncExternalStore } from 'react';
-import { useComponent } from '@mosetta/react';
+import { useComponent, useDiOptional, useNodeOptional } from '@mosetta/react';
 import { useDi } from '@mosetta/react';
+import { PAGE_MANAGER_TOKEN } from '@mosetta/runtime/client';
+import { blockOrigin } from '@mosetta/server-action/core';
 import {
   EServerActionStart,
   EXECUTION_ENV_TOKEN,
@@ -82,6 +84,13 @@ export function useServerAction<TIn extends {}, TOut>(
   ensureServerActionClient(di);
   const manager = useDi(SERVER_DATA_MANAGER);
   const { reference } = useComponent();
+  // where the call comes from — this node on the page shown now — for the host to read the
+  // block's settings itself (core.ts BLOCK_ORIGIN_HEADER); none outside a page. Asked again at
+  // every mutation: a block a move onto another page keeps is that page's block from then on
+  const pages = useDiOptional(PAGE_MANAGER_TOKEN);
+  const nodeId = useNodeOptional()?.id;
+  const originNow = (): string | null => blockOrigin(pages ? (pages.getCurrentPage() as { origin?: string }).origin : null, nodeId);
+  const origin = originNow();
 
   const env = useDi(EXECUTION_ENV_TOKEN);
   const recorder = useDi(SSR_ACTION_RECORDER_TOKEN);
@@ -116,18 +125,21 @@ export function useServerAction<TIn extends {}, TOut>(
         actionName: token.actionName,
         invalidates: mergeTags(token.invalidates, options.invalidates),
         customSerializer: token.customSerializer,
+        originOf: originNow,
       });
     }
     return null;
   });
 
-  const key = localHandle ? null : `${fullId}/${token.actionName}#${stableStringify(options.input)}`;
+  // two blocks of one tile asking with one input are two questions: the host answers each by its
+  // own block's settings
+  const key = localHandle ? null : `${fullId}/${token.actionName}#${stableStringify(options.input)}${origin ? `@${origin}` : ''}`;
   if (key !== null) {
     // render-phase, but idempotent by key (start-on-first-read); a new input → a new key → a new query
     manager.ensureQuery({
       key,
       tags: mergeTags(token.tags, options.tags),
-      request: { fullId, actionName: token.actionName, input: options.input },
+      request: { fullId, actionName: token.actionName, input: options.input, ...(origin ? { origin } : {}) },
       customSerializer: token.customSerializer,
     });
     // the head channel's counter waits for this query from the SAME render that started it