@phis/ui 0.4.2 → 0.4.4

package/gateway/internal-references.js

@@ -1,37 +1,62 @@
-import { isPhiRecord } from "../helpers/is-record";
 import "server-only";
 import { buildApiHeaders, buildApiUrl } from "../helpers/site-api";
+import { PhiMediaKind } from "../constants/media";
+import { readPhiFontMetricsFields } from "../components/media/media-font-metrics";
+import { createPhiResponseReader, requirePhiField } from "../components/widgets/config/strict-config-reader";
 import { readPhiPageReference } from "../types/references";
 import { throwPhiCmsGatewayError } from "./errors";
 import { peekPhiSiteReadCache, writePhiSiteReadCache } from "./site-read-cache";
 function readResolvedPage(entry) {
-    if (!isPhiRecord(entry)) {
-        throw new Error("Invalid internal Page reference projection.");
-    }
-    const value = entry;
-    const parsed = readPhiPageReference(value.reference);
-    if (!parsed || (value.path !== null && typeof value.path !== "string") || typeof value.deleted !== "boolean") {
-        throw new Error("Invalid internal Page reference projection.");
-    }
+    const reader = createPhiResponseReader(entry, "The internal reference projection");
+    const parsed = readPhiPageReference(reader.record.reference) ?? reader.fail("reference", "a Page reference");
+    const path = reader.record.path;
     return {
         reference: parsed.reference,
-        path: value.path,
-        deleted: value.deleted,
-        targetKind: value.targetKind === "module" ? "module" : "site",
+        path: path === null ? null : requirePhiField(reader, "path", "a path or null", reader.string),
+        deleted: requirePhiField(reader, "deleted", "true or false", reader.boolean),
+        targetKind: requirePhiField(reader, "targetKind", '"site" or "module"', (key) => reader.oneOf(key, ["site", "module"])),
     };
 }
-/** One Asset of the public reference projection, as the server writes it; a shape it does not match throws. */
+const PHI_MEDIA_KINDS = Object.values(PhiMediaKind);
+/**
+ * One Asset of the public reference projection, as the server writes it; a shape it does not match throws.
+ *
+ * Every field, not five of them: what passed here went straight into a rendered page under a type that
+ * promised a focal rectangle and font metrics nobody had looked at.
+ */
 export function readPhiPublicMediaAssetReference(entry) {
-    if (!isPhiRecord(entry)) {
-        throw new Error("Invalid internal Asset reference projection.");
-    }
-    const value = entry;
-    if (!Number.isSafeInteger(value.id) || value.id <= 0 ||
-        typeof value.deliveryUrl !== "string" || !Number.isSafeInteger(value.deliveryRevision) ||
-        typeof value.contentType !== "string" || typeof value.originalName !== "string") {
-        throw new Error("Invalid internal Asset reference projection.");
-    }
-    return value;
+    const reader = createPhiResponseReader(entry, "The internal reference projection");
+    const integer = (key) => requirePhiField(reader, key, "a whole number", reader.integer);
+    const text = (key) => requirePhiField(reader, key, "a text", reader.string);
+    const nullableNumber = (key) => reader.number(key) ?? null;
+    const nullableText = (key) => reader.string(key) ?? null;
+    const id = integer("id");
+    if (id <= 0)
+        reader.fail("id", "a positive whole number");
+    return {
+        id,
+        deliveryUrl: text("deliveryUrl"),
+        deliveryRevision: integer("deliveryRevision"),
+        variantVersion: reader.integer("variantVersion") ?? null,
+        contentType: text("contentType"),
+        kind: requirePhiField(reader, "kind", "a media kind", (key) => reader.oneOf(key, PHI_MEDIA_KINDS)),
+        originalName: text("originalName"),
+        width: nullableNumber("width"),
+        height: nullableNumber("height"),
+        blurDataUrl: nullableText("blurDataUrl"),
+        title: nullableText("title"),
+        altText: nullableText("altText"),
+        thumbnailUrl: nullableText("thumbnailUrl"),
+        previewUrl: nullableText("previewUrl"),
+        focalRect: reader.object("focalRect", (rect) => {
+            const fraction = (key) => {
+                const value = requirePhiField(rect, key, "a number from 0 to 1", rect.number);
+                return value >= 0 && value <= 1 ? value : rect.fail(key, "a number from 0 to 1");
+            };
+            return { x: fraction("x"), y: fraction("y"), width: fraction("width"), height: fraction("height") };
+        }) ?? null,
+        font: reader.object("font", readPhiFontMetricsFields) ?? null,
+    };
 }
 /** What the server takes per list in one request (`MAX_REFERENCES_PER_REQUEST`). */
 const PHI_REFERENCES_PER_REQUEST = 256;

package/gateway/site-cms-write-validation.d.ts

@@ -0,0 +1,9 @@
+import "server-only";
+import type { NextRequest } from "next/server";
+import type { PhiSiteAreaBridgeLoader } from "./site-area-bridges";
+/**
+ * The 422 for a write that carries an unreadable Widget config, or `null` to let it through.
+ *
+ * The body is read from a clone, so the request still goes upstream untouched.
+ */
+export declare function validatePhiCmsStructureWrite(request: NextRequest, loadAreaBridge: PhiSiteAreaBridgeLoader): Promise<Response | null>;

package/gateway/site-cms-write-validation.js

@@ -0,0 +1,78 @@
+import "server-only";
+import { isPhiCmsAreaKey } from "../constants/cms-areas";
+import { isPhiRecord } from "../helpers/is-record";
+import { buildPhiRuntimeModuleWidgetType } from "../plugins/runtime-modules/contracts";
+import { isPhiConfigError } from "../components/widgets/config/strict-config-reader";
+import { jsonResponse } from "./route-handler-helpers";
+function buildWidgetDefinitionsByType(catalog) {
+    const definitions = new Map();
+    for (const entry of catalog.values()) {
+        for (const widget of entry.widgets) {
+            definitions.set(buildPhiRuntimeModuleWidgetType(widget), widget.definition);
+        }
+    }
+    return definitions;
+}
+function findConfigIssue(body, definitions) {
+    const pending = [body];
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (Array.isArray(value)) {
+            pending.push(...value);
+            continue;
+        }
+        if (!isPhiRecord(value))
+            continue;
+        const widgetType = value.widgetType;
+        const config = value.config;
+        if (typeof widgetType === "string" && isPhiRecord(config)) {
+            const definition = definitions.get(widgetType);
+            if (definition) {
+                try {
+                    definition.parseConfig(config);
+                }
+                catch (error) {
+                    /*
+                     * Any error, not only the strict reader's: a Widget from another package may refuse its config
+                     * in its own words, and the live page leaves that Widget out just the same. Only the strict
+                     * reader can say which field it was.
+                     */
+                    return {
+                        widgetType,
+                        nodeId: value.id ?? null,
+                        path: isPhiConfigError(error) ? error.path : null,
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+        }
+        pending.push(...Object.values(value));
+    }
+    return null;
+}
+/**
+ * The 422 for a write that carries an unreadable Widget config, or `null` to let it through.
+ *
+ * The body is read from a clone, so the request still goes upstream untouched.
+ */
+export async function validatePhiCmsStructureWrite(request, loadAreaBridge) {
+    const body = await request.clone().json().catch(() => null);
+    if (!isPhiRecord(body))
+        return null;
+    const area = typeof body.area === "string" ? body.area.trim().toLowerCase() : "";
+    if (!isPhiCmsAreaKey(area))
+        return null;
+    const bridge = await loadAreaBridge(area);
+    if (!bridge)
+        return null;
+    const issue = findConfigIssue(body, buildWidgetDefinitionsByType(bridge.runtimeModuleCatalog));
+    if (!issue)
+        return null;
+    return jsonResponse({
+        error: `${issue.widgetType}: ${issue.message}`,
+        code: "invalid-config",
+        widgetType: issue.widgetType,
+        nodeId: issue.nodeId,
+        field: issue.path,
+    }, 422);
+}

package/gateway/site-proxy.js

@@ -76,6 +76,22 @@ function clearingReadCacheOnWrite(handler) {
         return response;
     };
 }
+/**
+ * A CMS structure write is checked against the Widgets' own parsers before it goes upstream
+ * (`site-cms-write-validation.ts`), so a config no Widget can read is refused with the field it is in
+ * rather than stored and left out of the live page. Loaded with the first such write.
+ */
+function validatingCmsStructureWrite(handler, loadAreaBridge) {
+    return async (request, context) => {
+        if ((await context.params).path?.[0] === "cms") {
+            const { validatePhiCmsStructureWrite } = await import("./site-cms-write-validation");
+            const refusal = await validatePhiCmsStructureWrite(request, loadAreaBridge);
+            if (refusal)
+                return refusal;
+        }
+        return handler(request, context);
+    };
+}
 export function buildPhiSiteProxyHandlers(options) {
     const { upstreamBaseUrl, timeoutMs, buildHeaders, logLabel = "[phis-ui][/api/site proxy]", missingBaseUrlMessage = "Missing apiBaseUrl for /api/site proxy.", } = options;
     const handlers = PhiNextProxy({
@@ -122,9 +138,9 @@ export function buildPhiSiteProxyHandlers(options) {
         GET: answeringLocally("GET", handlers.GET),
         HEAD: answeringLocally("HEAD", handlers.HEAD),
         OPTIONS: answeringLocally("OPTIONS", handlers.OPTIONS),
-        POST: answeringLocally("POST", clearingReadCacheOnWrite(handlers.POST)),
-        PUT: answeringLocally("PUT", clearingReadCacheOnWrite(handlers.PUT)),
-        PATCH: answeringLocally("PATCH", clearingReadCacheOnWrite(handlers.PATCH)),
+        POST: answeringLocally("POST", validatingCmsStructureWrite(clearingReadCacheOnWrite(handlers.POST), options.loadAreaBridge)),
+        PUT: answeringLocally("PUT", validatingCmsStructureWrite(clearingReadCacheOnWrite(handlers.PUT), options.loadAreaBridge)),
+        PATCH: answeringLocally("PATCH", validatingCmsStructureWrite(clearingReadCacheOnWrite(handlers.PATCH), options.loadAreaBridge)),
         DELETE: answeringLocally("DELETE", clearingReadCacheOnWrite(handlers.DELETE)),
     };
 }

package/helpers/cms-container-chrome.js

@@ -9,7 +9,12 @@ import { resolvePhiSurfaceStyle } from "./surface-style";
  * would show through as the default after all.
  */
 export function resolvePhiCmsContainerSurface(config) {
-    const resolved = resolvePhiSurfaceStyle(config.surface, { groundLayer: false });
+    /*
+     * An Overlay draws no tone -- neither the class nor the scope -- so it does not paint a tone's ground
+     * either: without the class the ground would be the page's, laid over the Overlay's own.
+     */
+    const surface = config.surface?.tone ? { ...config.surface, tone: undefined } : config.surface;
+    const resolved = resolvePhiSurfaceStyle(surface, { groundLayer: false });
     const background = config.surface?.background
         ? normalizePhiBackgroundWidgetConfig(config.surface.background)
         : null;

package/helpers/locale.d.ts

@@ -31,6 +31,14 @@ export declare function isPhiLocaleReadableAsSource(locale: string, source: stri
 export declare function resolvePhiTranslationLocale(input: string | null | undefined): string;
 export declare function normalizeLocale(input: string | null | undefined, options?: NormalizeLocaleOptions): SiteLocale;
 export declare function localizePath(locale: SiteLocale | string, targetPath: string): string;
+/**
+ * A Public path in the language being read, unless it already names one.
+ *
+ * A path stored without a locale (`/home`) gets `locale` in front, as `/` does; one whose first segment
+ * is one of the Site's locales (`/de/home`) and an external URL stay as they are. The locales are needed
+ * to tell a locale segment from a page, which `matchPhiLocalePrefixSegment` does.
+ */
+export declare function localizePathUnlessLocalized(locale: SiteLocale | string, targetPath: string, availableLocales: readonly string[]): string;
 /**
  * The path for a staff Area, which carries no locale prefix.
  *

package/helpers/locale.js

@@ -1,4 +1,5 @@
 import { PHI_CMS_AREA_KEYS } from "../constants/cms-areas";
+import { isPhiExternalHref } from "./external-href";
 export { PHI_CANONICAL_SOURCE_LOCALE } from "@phis/contracts/locale";
 import { PHI_CANONICAL_SOURCE_LOCALE } from "@phis/contracts/locale";
 export const SUPPORTED_CMS_AREAS = PHI_CMS_AREA_KEYS;
@@ -117,6 +118,23 @@ function prefixPath(prefix, targetPath) {
 export function localizePath(locale, targetPath) {
     return prefixPath(locale, targetPath);
 }
+/**
+ * A Public path in the language being read, unless it already names one.
+ *
+ * A path stored without a locale (`/home`) gets `locale` in front, as `/` does; one whose first segment
+ * is one of the Site's locales (`/de/home`) and an external URL stay as they are. The locales are needed
+ * to tell a locale segment from a page, which `matchPhiLocalePrefixSegment` does.
+ */
+export function localizePathUnlessLocalized(locale, targetPath, availableLocales) {
+    if (isPhiExternalHref(targetPath)) {
+        return targetPath;
+    }
+    const firstSegment = targetPath.split("/").filter(Boolean)[0];
+    if (firstSegment && matchPhiLocalePrefixSegment(firstSegment, { availableLocales })) {
+        return targetPath;
+    }
+    return localizePath(locale, targetPath);
+}
 /**
  * The path for a staff Area, which carries no locale prefix.
  *

package/helpers/renderable-block-serialization.js

@@ -65,7 +65,7 @@ function normalizeRenderableBlockTransitionTrigger(value) {
         : undefined;
 }
 function normalizeRenderableBlockViewportEffectAxis(value) {
-    return value === "x" || value === "y" ? value : undefined;
+    return value === "x" || value === "y" || value === "z" ? value : undefined;
 }
 function normalizeRenderableBlockViewportEffectProperty(value) {
     return value === "translate" ||

package/helpers/shell-region-style.js

@@ -209,7 +209,8 @@ export function resolvePhiShellRegionGroundStyle(ground) {
 export function resolvePhiShellSiderWidth(shellTheme) {
     return (resolvePhiShellMetric(shellTheme, "width", { family: "sider", region: "left" }) ??
         resolvePhiShellMetric(shellTheme, "width", { family: "sider", region: "right" }) ??
-        200);
+        // The scale's sider width, which the Builder's defaults and the page grid already use.
+        PHI_LAYOUT.sidebarWidth);
 }
 export function resolvePhiShellSiderCollapsedWidth(shellTheme) {
     return (resolvePhiShellMetric(shellTheme, "collapsedWidth", { family: "sider", region: "left" }) ??

package/helpers/surface-style.d.ts

@@ -50,6 +50,14 @@ export type PhiSurfaceStyleOptions = {
      */
     groundLayer?: boolean;
 };
+/** The ground a toned Surface paints where it states none: the container ground of the tone's mode. */
+export declare const PHI_SURFACE_TONE_GROUND = "var(--ant-color-bg-container)";
+/**
+ * Whether a Surface takes its tone's ground (`PHI_SURFACE_TONE_GROUND`): it asks for a mode of its own and
+ * its Background paints nothing. A stated ground wins, and the Theme's Overlay (`base.kind: "theme"`) is
+ * one. The one rule for every box with a Surface -- this resolver's and the Region shell's.
+ */
+export declare function phiSurfaceTakesToneGround(tone: PhiSurface["tone"] | null | undefined, paintsGround: boolean): boolean;
 /**
  * A Surface as CSS, in one place for every box that has one.
  *
@@ -59,5 +67,8 @@ export type PhiSurfaceStyleOptions = {
  * (a pane's) combined with the configured one.
  */
 export declare function resolvePhiSurfaceStyle(surface: PhiSurface | null | undefined, options?: PhiSurfaceStyleOptions): PhiResolvedSurface;
-/** Whether a Surface draws anything a reader could see: a ground, a line, or depth. */
+/**
+ * Whether a Surface draws anything a reader could see: a ground (its own, or its tone's), a line, or
+ * depth.
+ */
 export declare function phiSurfaceDrawsChrome(surface: PhiSurface | null | undefined): boolean;

package/helpers/surface-style.js

@@ -1,8 +1,18 @@
-import { normalizePhiBackgroundWidgetConfig, phiBackgroundWidgetConfigPaintsGround, resolvePhiBackgroundGroundFilter, resolvePhiBackgroundMotion, resolvePhiBackgroundMotionHostStyle, resolvePhiBackgroundWidgetStyle, } from "../components/widgets/config/background";
+import { PHI_BACKGROUND_CONTAINER_GROUND, normalizePhiBackgroundWidgetConfig, phiBackgroundWidgetConfigPaintsGround, resolvePhiBackgroundGroundFilter, resolvePhiBackgroundMotion, resolvePhiBackgroundMotionHostStyle, resolvePhiBackgroundWidgetStyle, } from "../components/widgets/config/background";
 import { resolvePhiCmsBorderSource } from "../types/cms-border-source";
 import { resolvePhiSurfaceToneClassName } from "../types/surface";
 import { resolvePhiSourcedBorderStyle } from "./border-widget-style";
 import { combinePhiBoxShadows, resolvePhiShadow } from "./layout-style";
+/** The ground a toned Surface paints where it states none: the container ground of the tone's mode. */
+export const PHI_SURFACE_TONE_GROUND = PHI_BACKGROUND_CONTAINER_GROUND;
+/**
+ * Whether a Surface takes its tone's ground (`PHI_SURFACE_TONE_GROUND`): it asks for a mode of its own and
+ * its Background paints nothing. A stated ground wins, and the Theme's Overlay (`base.kind: "theme"`) is
+ * one. The one rule for every box with a Surface -- this resolver's and the Region shell's.
+ */
+export function phiSurfaceTakesToneGround(tone, paintsGround) {
+    return tone != null && tone !== "inherit" && !paintsGround;
+}
 const PHI_SURFACE_EMPTY = { style: {}, ground: null, paintsGround: false };
 function resolvePhiSurfaceCorners(fallback, configured) {
     const corner = (value) => value ?? fallback ?? undefined;
@@ -30,8 +40,13 @@ export function resolvePhiSurfaceStyle(surface, options = {}) {
     const paintsGround = phiBackgroundWidgetConfigPaintsGround(background);
     const groundFilter = background ? resolvePhiBackgroundGroundFilter(background) : null;
     const motion = background ? resolvePhiBackgroundMotion(background) : null;
+    /*
+     * The Theme's Overlay never goes on a layer: it is a window onto one viewport-sized painting, so there
+     * is nothing to move or zoom, and its pane has to frost the page behind the box rather than the box.
+     */
     const needsGroundLayer = options.groundLayer !== false
         && paintsGround
+        && background?.base.kind !== "theme"
         && (groundFilter != null || motion != null || options.forceGroundLayer === true);
     const paint = background ? resolvePhiBackgroundWidgetStyle(background) : {};
     const hostPaint = needsGroundLayer
@@ -44,6 +59,12 @@ export function resolvePhiSurfaceStyle(surface, options = {}) {
             motion: motion ? background : null,
         }
         : null;
+    /*
+     * A tone turns the ground as well (LAYOUTING.md "Surface tone"): content in another mode on the page's
+     * ground would be light words on a light page. Where the Background paints nothing, the box takes the
+     * mode's own container ground, which resolves under the tone's class it carries. A stated ground wins.
+     */
+    const toneGround = phiSurfaceTakesToneGround(surface.tone, paintsGround);
     const borderSource = resolvePhiCmsBorderSource(surface.borderSource, surface.border);
     const edge = resolvePhiSourcedBorderStyle(borderSource, surface.border);
     const { border: line, ...configuredCorners } = edge;
@@ -51,6 +72,7 @@ export function resolvePhiSurfaceStyle(surface, options = {}) {
     return {
         style: {
             ...hostPaint,
+            ...(toneGround ? { backgroundColor: PHI_SURFACE_TONE_GROUND } : {}),
             ...(line == null ? {} : { border: line }),
             ...resolvePhiSurfaceCorners(options.cornerFallback, configuredCorners),
             ...(boxShadow == null ? {} : { boxShadow }),
@@ -63,12 +85,16 @@ export function resolvePhiSurfaceStyle(surface, options = {}) {
         ...(surface.tone ? { className: resolvePhiSurfaceToneClassName(surface.tone) } : {}),
     };
 }
-/** Whether a Surface draws anything a reader could see: a ground, a line, or depth. */
+/**
+ * Whether a Surface draws anything a reader could see: a ground (its own, or its tone's), a line, or
+ * depth.
+ */
 export function phiSurfaceDrawsChrome(surface) {
     if (!surface) {
         return false;
     }
     return phiBackgroundWidgetConfigPaintsGround(surface.background ?? null)
+        || (surface.tone != null && surface.tone !== "inherit")
         || resolvePhiCmsBorderSource(surface.borderSource, surface.border) !== "none"
         || (surface.shadow != null && surface.shadow !== "none");
 }

package/module-dashboard-cards.d.ts

@@ -11,5 +11,5 @@
  * headers itself, which is a copy of a protocol that is this package's to change. See DASHBOARD.md.
  */
 import "server-only";
-export { createPhiDashboardCardId, isPhiDashboardCardId, type PhiDashboardCardContext, type PhiDashboardCardDescriptor, type PhiDashboardCardForm, type PhiDashboardCardId, type PhiDashboardCardPayload, type PhiDashboardCardProvider, } from "./types/dashboard-cards";
+export { createPhiDashboardCardId, isPhiDashboardCardId, PHI_DASHBOARD_CARD_SERIES_LIMIT, type PhiDashboardCardContext, type PhiDashboardCardDescriptor, type PhiDashboardCardForm, type PhiDashboardCardId, type PhiDashboardCardPayload, type PhiDashboardCardProvider, type PhiDashboardCardSeries, type PhiDashboardCardSeriesPoint, } from "./types/dashboard-cards";
 export { fetchPhiSiteApi, type PhiSiteApiRequest } from "./gateway/site-api-request";

package/module-dashboard-cards.js

@@ -11,5 +11,5 @@
  * headers itself, which is a copy of a protocol that is this package's to change. See DASHBOARD.md.
  */
 import "server-only";
-export { createPhiDashboardCardId, isPhiDashboardCardId, } from "./types/dashboard-cards";
+export { createPhiDashboardCardId, isPhiDashboardCardId, PHI_DASHBOARD_CARD_SERIES_LIMIT, } from "./types/dashboard-cards";
 export { fetchPhiSiteApi } from "./gateway/site-api-request";

package/next/config.d.mts

@@ -15,6 +15,9 @@ export declare function generatePhiAntdStaticCss(projectDir?: string): {
 /** The generated file for the Ant Design installed for `projectDir`, written once per input. */
 export declare function ensurePhiAntdStaticCss(projectDir?: string): string;
 
+/** The host in `config/site-runtime.json`'s `site.publicUrl` under `dir`, or `null` where there is none. */
+export declare function readPhiSitePublicHost(dir?: string): string | null;
+
 /**
  * A Site's `next.config`, with `@phis/ui/antd-static.css` resolved to the structure generated for its
  * Ant Design. `dir` is the Site's root, the directory its `package.json` is in.

package/next/config.mjs

@@ -257,15 +257,42 @@ export function ensurePhiAntdStaticCss(projectDir = process.cwd()) {
   return file;
 }
 
+/**
+ * The host the Site is reached at, from `config/site-runtime.json` (`site.publicUrl`), or `null` where the
+ * file or the field is absent -- a build outside a Site checkout has neither.
+ *
+ * The dev server serves its own resources only to the hosts in `allowedDevOrigins`; a page opened through
+ * any other host arrives as HTML and never hydrates -- no menu opens, nothing measured in the browser lays
+ * out. The public host was a list a person had to keep, and the one Site that moved to `dev.phis.dev`
+ * was missing from it. The CLI writes the file when it scaffolds a Site, so the host is known here.
+ */
+export function readPhiSitePublicHost(dir = process.cwd()) {
+  const file = path.join(dir, "config", "site-runtime.json");
+  if (!existsSync(file)) return null;
+  const publicUrl = JSON.parse(readFileSync(file, "utf8"))?.site?.publicUrl;
+  if (publicUrl === undefined || publicUrl === null || publicUrl === "") return null;
+  if (typeof publicUrl !== "string" || !URL.canParse(publicUrl)) {
+    throw new Error(`config/site-runtime.json: site.publicUrl must be a URL, found ${JSON.stringify(publicUrl)}.`);
+  }
+  return new URL(publicUrl).hostname;
+}
+
 /**
  * A Site's `next.config`, with `@phis/ui/antd-static.css` resolved to the structure generated for its
- * Ant Design. `dir` is the Site's root, the directory its `package.json` is in.
+ * Ant Design, and the Site's own public host allowed to reach the dev server. `dir` is the Site's root,
+ * the directory its `package.json` is in.
  */
 export function withPhiNextConfig(nextConfig, { dir = process.cwd() } = {}) {
   // Turbopack takes no absolute path as an alias target; a relative one is read from the Site's root.
   const file = `./${path.relative(dir, ensurePhiAntdStaticCss(dir)).split(path.sep).join("/")}`;
+  const publicHost = readPhiSitePublicHost(dir);
+  const allowedDevOrigins = [...new Set([
+    ...(nextConfig.allowedDevOrigins ?? []),
+    ...(publicHost ? [publicHost] : []),
+  ])];
   return {
     ...nextConfig,
+    ...(allowedDevOrigins.length > 0 ? { allowedDevOrigins } : {}),
     turbopack: {
       ...nextConfig.turbopack,
       resolveAlias: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phis/ui",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -503,7 +503,7 @@
     "@lexical/rich-text": "0.50.0",
     "@lexical/selection": "0.50.0",
     "@lexical/utils": "0.50.0",
-    "@phis/contracts": "^0.6.0",
+    "@phis/contracts": "^0.7.0",
     "dayjs": "^1.11.23",
     "dom-serializer": "^2.0.0",
     "htmlparser2": "^10.1.0",

package/plugins/runtime/phi-slot-child-viewport-effects-observer.js

@@ -29,7 +29,8 @@ function applyEasing(progress, easing) {
     return progress;
 }
 function resolveProgress(effect, rect, viewportWidth, viewportHeight) {
-    const axis = effect.axis ?? PHI_RENDERABLE_BLOCK_DEFAULT_VIEWPORT_EFFECT.axis ?? "y";
+    // `z` has no extent on the page, so a turn about it follows the page's own scroll direction.
+    const axis = (effect.axis ?? PHI_RENDERABLE_BLOCK_DEFAULT_VIEWPORT_EFFECT.axis) === "x" ? "x" : "y";
     const targetStart = axis === "x" ? rect.left : rect.top;
     const rangeStart = resolveRangePoint(effect.rangeStart ?? PHI_RENDERABLE_BLOCK_DEFAULT_VIEWPORT_EFFECT.rangeStart, rect, viewportWidth, viewportHeight, axis);
     const rangeEnd = resolveRangePoint(effect.rangeEnd ?? PHI_RENDERABLE_BLOCK_DEFAULT_VIEWPORT_EFFECT.rangeEnd, rect, viewportWidth, viewportHeight, axis);
@@ -77,6 +78,9 @@ function resolveViewportEffectValues(effects, target) {
             if (axis === "x") {
                 values.rotateX = rotateValue;
             }
+            else if (axis === "z") {
+                values.rotateZ = rotateValue;
+            }
             else {
                 values.rotateY = rotateValue;
             }

package/plugins/runtime-modules/accounting/presets.d.ts

@@ -0,0 +1,9 @@
+import type { PhiCmsDescriptorBuildContext, PhiCmsRoutePresetDescriptor } from "../../../types/cms-module-descriptors";
+export declare const PHI_ACCOUNTING_RUNTIME_MODULE_AREA_SHELLS: {
+    ownerModuleId: "@phis/ui/modules/accounting";
+    presetKey: string;
+    shellPresetVersion: number;
+    area: "accounting";
+    loadTree: ({ page, runtime }: PhiCmsDescriptorBuildContext) => Promise<import("../../../types").PhiResolvedCmsPageTree>;
+}[];
+export declare const PHI_ACCOUNTING_RUNTIME_MODULE_ROUTES: PhiCmsRoutePresetDescriptor[];

package/plugins/runtime-modules/accounting/presets.js

@@ -0,0 +1,37 @@
+import { PHI_BASE_PAGE_LAYOUT_VERSION } from "../../../components/regions/presets/phi-base-page-layout";
+import { buildPhiAreaRootRoutePresetDescriptor } from "../area-root-route";
+import { PHI_ACCOUNTING_RUNTIME_MODULE_ID } from "./ids";
+/* What the Accounting base Module brings: the Site shell for its Area, the Area root and the overview. */
+export const PHI_ACCOUNTING_RUNTIME_MODULE_AREA_SHELLS = [
+    {
+        ownerModuleId: PHI_ACCOUNTING_RUNTIME_MODULE_ID,
+        presetKey: "accounting-area-preset",
+        shellPresetVersion: 1,
+        area: "accounting",
+        loadTree: ({ page, runtime }) => import("../phi-default-site-area-preset-tree")
+            .then((module) => module.buildPhiDefaultSiteAreaPresetTree({
+            page,
+            runtime,
+            presetKey: "accounting-area-preset",
+            ownerModuleId: PHI_ACCOUNTING_RUNTIME_MODULE_ID,
+            runtimeModuleArea: "accounting",
+        })),
+    },
+];
+export const PHI_ACCOUNTING_RUNTIME_MODULE_ROUTES = [
+    buildPhiAreaRootRoutePresetDescriptor({
+        ownerModuleId: PHI_ACCOUNTING_RUNTIME_MODULE_ID,
+        area: "accounting",
+        title: "Accounting",
+    }),
+    {
+        ownerModuleId: PHI_ACCOUNTING_RUNTIME_MODULE_ID,
+        presetKey: "accounting-overview-page",
+        presetVersion: 1 + PHI_BASE_PAGE_LAYOUT_VERSION,
+        area: "accounting",
+        title: "Overview",
+        path: "/overview",
+        loadTree: ({ page, runtime }) => import("./trees/phi-default-accounting-page-tree")
+            .then((module) => module.buildPhiDefaultAccountingPageTree({ page, runtime })),
+    },
+];

package/plugins/runtime-modules/accounting/server.d.ts

@@ -1,5 +1,2 @@
-/**
- * The unselectable base module of its Area. Shells and routes come from the shared Area-base preset
- * list and are filtered by owner, so each base module states its own half of it.
- */
+/** The unselectable base module of its Area. Its shell and Pages are its own (`./presets`). */
 export declare const PHI_ACCOUNTING_RUNTIME_MODULE_SERVER_AREA_CONTRIBUTION: import("../area-contributions").PhiRuntimeModuleServerAreaContribution;

package/plugins/runtime-modules/accounting/server.js

@@ -1,18 +1,15 @@
-import { PHI_AREA_BASE_RUNTIME_MODULE_AREA_SHELLS, PHI_AREA_BASE_RUNTIME_MODULE_ROUTES, } from "../area-base-presets";
+import { PHI_ACCOUNTING_RUNTIME_MODULE_AREA_SHELLS, PHI_ACCOUNTING_RUNTIME_MODULE_ROUTES, } from "./presets";
 import { definePhiRuntimeModuleServerAreaContribution } from "../area-contributions";
 import { PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION } from "../accounting/definition";
-/**
- * The unselectable base module of its Area. Shells and routes come from the shared Area-base preset
- * list and are filtered by owner, so each base module states its own half of it.
- */
+/** The unselectable base module of its Area. Its shell and Pages are its own (`./presets`). */
 export const PHI_ACCOUNTING_RUNTIME_MODULE_SERVER_AREA_CONTRIBUTION = definePhiRuntimeModuleServerAreaContribution({
     moduleId: PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION.moduleId,
     catalogEntry: {
         definition: PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION,
         widgets: [],
         layouts: [],
-        areaShells: PHI_AREA_BASE_RUNTIME_MODULE_AREA_SHELLS.filter((descriptor) => descriptor.ownerModuleId === PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION.moduleId),
-        routes: PHI_AREA_BASE_RUNTIME_MODULE_ROUTES.filter((descriptor) => descriptor.ownerModuleId === PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION.moduleId),
+        areaShells: PHI_ACCOUNTING_RUNTIME_MODULE_AREA_SHELLS,
+        routes: PHI_ACCOUNTING_RUNTIME_MODULE_ROUTES,
         load: () => import("./module").then((module) => module.PHI_ACCOUNTING_RUNTIME_MODULE),
     },
 });

package/plugins/runtime-modules/app/presets.d.ts

@@ -0,0 +1,18 @@
+import type { PhiCmsDescriptorBuildContext, PhiCmsRoutePresetDescriptor } from "../../../types/cms-module-descriptors";
+export declare const PHI_APP_RUNTIME_MODULE_AREA_SHELLS: {
+    ownerModuleId: "@phis/ui/modules/app";
+    presetKey: string;
+    shellPresetVersion: number;
+    area: "app";
+    loadTree: ({ page, runtime }: PhiCmsDescriptorBuildContext) => Promise<{
+        pageMeta: import("../../../types").PhiCmsResolvedPageMeta | null | undefined;
+        runtimeModuleIds: `${string}/${string}`[] | null | undefined;
+        regions: import("../../../types").PhiCmsRegionNode[];
+        overlays: import("../../../types").PhiCmsOverlayNode[];
+        layoutNodes: import("../../../types").PhiCmsLayoutNode[];
+        contentWidgets: import("../../../types").PhiCmsContentWidgetNode[];
+        controllerSettings: import("../../../types/cms").PhiCmsTreeControllerSettings;
+        page: import("../../../types").PhiCmsPageNode;
+    }>;
+}[];
+export declare const PHI_APP_RUNTIME_MODULE_ROUTES: PhiCmsRoutePresetDescriptor[];