@phis/ui 0.2.1 → 0.3.0

package/types/table-widget.d.ts

@@ -82,6 +82,13 @@ export type PhiTableColumnDefinition = {
     editor?: {
         control?: PhiTableColumnEditorControl;
         disabledWhen?: PhiRuntimeConditionExpression;
+        /**
+         * The unit beside a number editor -- "days", "ms" -- already in the reader's language.
+         *
+         * The value's and not the column's: a title saying "Window (days)" leaves the number unitless the
+         * moment the header scrolls away, and invites somebody to type the unit in as well.
+         */
+        prefix?: string;
     };
     sizing?: PhiTableColumnSizing;
     align?: "left" | "center" | "right";
@@ -171,6 +178,12 @@ export type PhiTableRowSelectionConfig = {
     mode?: "none" | "single" | "multiple";
     preserveSelectedRowIdentities?: boolean;
     disabledWhen?: PhiRuntimeConditionExpression;
+    /**
+     * Row fields `selectionChange` carries alongside the identities, for a receiver that has to know
+     * something about what was chosen -- whether a group is retired -- and should not ask the server for
+     * what the Table already holds. Named fields only: a selection does not broadcast whole rows.
+     */
+    emitFields?: readonly string[];
 };
 export type PhiTableColumnReorderingConfig = {
     enabled?: boolean;
@@ -244,10 +257,28 @@ export type PhiTableFooterValueBinding = {
     key: string;
     value: PhiTableSummaryValueSource;
 };
+/**
+ * A footer line said differently while one value holds.
+ *
+ * The template fills placeholders and nothing else, so a sentence that changes with the state -- "3 of 5
+ * left" against "Used up" -- is two templates, not one with a condition inside. The first variant whose
+ * `when` holds replaces `template` and `values`; none holding leaves the footer as declared. A variant
+ * may name no values: "Used up" has nothing to fill in. An empty template takes the footer away while it
+ * holds -- a line about a limit has nothing to say where there is none.
+ */
+export type PhiTableFooterVariant = {
+    when: {
+        value: PhiTableSummaryValueSource;
+        operator: "truthy" | "falsy";
+    };
+    template: string;
+    values?: readonly PhiTableFooterValueBinding[];
+};
 export type PhiTableFooterConfig = {
     template: string;
     values: readonly PhiTableFooterValueBinding[];
     align?: "start" | "center" | "end";
+    variants?: readonly PhiTableFooterVariant[];
 };
 export type PhiTableSummaryConfig = {
     placement?: "body-end" | "sticky-top" | "sticky-bottom";
@@ -304,6 +335,16 @@ export type PhiTableWidgetConfig = {
     presentation: PhiTableWidgetPresentation;
     features: PhiTableWidgetFeatures;
     initialQuery?: PhiTableQuery;
+    /**
+     * Filters the Page sets and the reader does not: what makes a listing the listing it is, such as a
+     * thread Provider's `kind` pinned to Support.
+     *
+     * Not a filter with a start value. A `features.filters` entry is the reader's -- drawn, changeable,
+     * reset to its default -- and `initialQuery.filters` is only where the query starts, so a signal that
+     * sets the query replaces it. These are drawn nowhere and merged into every query last, over the
+     * reader's filters, a reset and any signal alike, with their values in their own type.
+     */
+    fixedFilters?: Readonly<Record<string, PhiTableQueryValue>>;
     source: PhiProviderResourceSource | null;
     signalRoutes?: PhiSignalRouteSet | null;
 };
@@ -321,6 +362,15 @@ export type PhiTableWidgetState = {
 };
 export type PhiTableSelectionSignalValue = {
     selectedRowIdentities: readonly PhiTableRowIdentity[];
+    /**
+     * The `rowSelection.emitFields` of each selected row the Table has loaded; a row kept selected from
+     * another page is not in it. Absent where the placement names no fields.
+     */
+    selectedRows?: readonly PhiTableSelectedRow[];
+};
+export type PhiTableSelectedRow = {
+    rowIdentity: PhiTableRowIdentity;
+    values: Readonly<Record<string, PhiTableQueryValue>>;
 };
 export type PhiTableColumnOrderSignalValue = {
     columnOrder: readonly string[];

package/types/table-widget.js

@@ -1,3 +1,4 @@
+import { readPhiDotPath } from "../helpers/dot-path";
 import { isPhiRecord } from "../helpers/is-record";
 import { isPhiTableQueryValue, readRowIdentities } from "./table-signal-values";
 export const PHI_TABLE_TAG_COLORS = [
@@ -155,13 +156,11 @@ export function readPhiTableProviderMutationResult(value) {
 export function readPhiTableRowOptions(row, field) {
     if (!row || !field.rowOptionsPath)
         return null;
-    const value = field.rowOptionsPath.split(".").filter(Boolean).reduce((current, segment) => current && typeof current === "object" && !Array.isArray(current)
-        ? current[segment]
-        : undefined, row);
+    const value = readPhiDotPath(row, field.rowOptionsPath);
     if (!Array.isArray(value))
         return null;
     return value.flatMap((entry) => {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        if (!isPhiRecord(entry))
             return [];
         const record = entry;
         return typeof record.value === "string" && typeof record.label === "string"

package/types/thread-widget.js

@@ -1,5 +1,6 @@
+import { isPhiRecord } from "../helpers/is-record";
 export function readPhiThreadSignalValue(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
+    if (!isPhiRecord(value)) {
         return null;
     }
     const threadId = value.threadId;

package/types/tours.d.ts

@@ -0,0 +1,84 @@
+import { type PhiSignalAddress } from "./signals";
+/**
+ * Guided Tours ([design/TOURS.md](../design/TOURS.md)).
+ *
+ * A Tour belongs to a Page: the Module that owns a route preset may attach one to it, the request
+ * resolution translates it with the Page, and whichever Controller in the Area says it takes Page Tours
+ * (`pageTour` among its flags) receives it as a Page overlay of its config. There is no registry of
+ * Tours and no Tour content in the CMS.
+ */
+/**
+ * The addresses a step can point at: a CMS instance, one of its declared subcontrols, a Region. A
+ * Controller is an address too, but it owns no element, so it is never a visual target.
+ */
+export type PhiVisualAnchorAddress = Exclude<PhiSignalAddress, `controller:${string}`>;
+/**
+ * The attribute a Phi Control marks one of its parts with -- a Table's header row, its toolbar -- so the
+ * Widget drawing that Control can offer the part as `cms:<instanceId>:<part>` (design/TOURS.md,
+ * Visual-anchor registration). An inert mark until a Widget registers the part: the address is the
+ * Widget's contract, the attribute only says where the part is drawn.
+ */
+export declare const PHI_VISUAL_ANCHOR_PART_ATTRIBUTE = "data-phi-anchor-part";
+/** The instance a part address belongs to -- `cms:<id>` of `cms:<id>:<part>` -- or `null` for a whole one. */
+export declare function readPhiVisualAnchorOwner(address: string): PhiVisualAnchorAddress | null;
+/**
+ * Where a step's panel sits relative to its target. Four sides, not Ant Design's twelve: a Tour points
+ * at something, and the corner variants are layout tuning no definition should have to carry.
+ */
+export type PhiTourPlacement = "top" | "bottom" | "left" | "right";
+/** What a step does when its target is not there to point at: pass over it, or end the Tour. */
+export type PhiTourMissingTargetPolicy = "skip" | "stop";
+export type PhiTourStepDefinition = {
+    /** The step's identity within its Tour; progress is stored under it, never under a position. */
+    key: string;
+    /**
+     * What the step points at, or `null` for a step that is centered on purpose. A target that is not found
+     * is never turned into a centered step -- `ifMissing` decides instead.
+     */
+    target: PhiVisualAnchorAddress | null;
+    /** In the owning Module's language; translated with the Page. */
+    title: string;
+    description?: string;
+    placement?: PhiTourPlacement;
+    ifMissing?: PhiTourMissingTargetPolicy;
+};
+export type PhiTourDefinition = {
+    /** `<module id>/<key>`: namespaced by the Module that owns the Page. */
+    id: `${string}/${string}`;
+    /**
+     * A positive integer. Raising it is a new learning revision: whoever completed or dismissed the
+     * previous one is offered the Tour again. Progress is compared with it, never with the steps.
+     */
+    version: number;
+    steps: readonly PhiTourStepDefinition[];
+};
+/** The words around every Tour, from the Core label set. */
+export type PhiTourLabels = {
+    next: string;
+    previous: string;
+    finish: string;
+};
+/** A Tour as the Page hands it on: its texts in the viewer's language, and the buttons' words. */
+export type PhiResolvedPageTour = PhiTourDefinition & {
+    labels: PhiTourLabels;
+};
+/**
+ * Where a Tour is asked for: the Tour Controller of the Area, which the Tour Module mounts.
+ *
+ * Here, in the foundation, rather than in that Module: the Tour button is Core's, so any Area -- and any
+ * Module's own Page -- can place it without depending on the Tour Module. With the Module off nobody
+ * answers at this address, and the button, never told that a Tour is there, stays hidden.
+ */
+export declare const PHI_TOUR_CONTROLLER_PLUGIN_KEY = "@phis/ui/modules/tour/controller";
+export declare const PHI_TOUR_CONTROLLER_KEY = "default";
+export declare const PHI_TOUR_CONTROLLER_ADDRESS: `controller:${string}/${string}:${string}`;
+/** The flag a Controller definition carries to receive the shown Page's Tour as `pageTour` in its config. */
+export declare const PHI_PAGE_TOUR_CONTROLLER_FLAG = "pageTour";
+/** The config key the Page's Tour arrives under. */
+export declare const PHI_PAGE_TOUR_CONFIG_KEY = "pageTour";
+/** What is wrong with a definition, as sentences; empty when nothing is. */
+export declare function collectPhiTourDefinitionErrors(definition: PhiTourDefinition): string[];
+/** The addresses a Tour points at, which the render has to draw with a live frame to be found. */
+export declare function readPhiTourTargets(tour: Pick<PhiTourDefinition, "steps"> | null | undefined): PhiVisualAnchorAddress[];
+/** A Page Tour as it arrives in a Controller's config, or `null` for anything that is not one. */
+export declare function readPhiResolvedPageTour(value: unknown): PhiResolvedPageTour | null;

package/types/tours.js

@@ -0,0 +1,75 @@
+import { PHI_SHARED_PACKAGE_NAME, createPhiControllerSignalAddress } from "./signals";
+/**
+ * The attribute a Phi Control marks one of its parts with -- a Table's header row, its toolbar -- so the
+ * Widget drawing that Control can offer the part as `cms:<instanceId>:<part>` (design/TOURS.md,
+ * Visual-anchor registration). An inert mark until a Widget registers the part: the address is the
+ * Widget's contract, the attribute only says where the part is drawn.
+ */
+export const PHI_VISUAL_ANCHOR_PART_ATTRIBUTE = "data-phi-anchor-part";
+/** The instance a part address belongs to -- `cms:<id>` of `cms:<id>:<part>` -- or `null` for a whole one. */
+export function readPhiVisualAnchorOwner(address) {
+    const [family, instanceId, part] = address.split(":");
+    return family === "cms" && instanceId && part ? `cms:${instanceId}` : null;
+}
+/**
+ * Where a Tour is asked for: the Tour Controller of the Area, which the Tour Module mounts.
+ *
+ * Here, in the foundation, rather than in that Module: the Tour button is Core's, so any Area -- and any
+ * Module's own Page -- can place it without depending on the Tour Module. With the Module off nobody
+ * answers at this address, and the button, never told that a Tour is there, stays hidden.
+ */
+export const PHI_TOUR_CONTROLLER_PLUGIN_KEY = `${PHI_SHARED_PACKAGE_NAME}/modules/tour/controller`;
+export const PHI_TOUR_CONTROLLER_KEY = "default";
+export const PHI_TOUR_CONTROLLER_ADDRESS = createPhiControllerSignalAddress(PHI_TOUR_CONTROLLER_PLUGIN_KEY, PHI_TOUR_CONTROLLER_KEY, "default");
+/** The flag a Controller definition carries to receive the shown Page's Tour as `pageTour` in its config. */
+export const PHI_PAGE_TOUR_CONTROLLER_FLAG = "pageTour";
+/** The config key the Page's Tour arrives under. */
+export const PHI_PAGE_TOUR_CONFIG_KEY = "pageTour";
+const TOUR_STEP_KEY_PATTERN = /^[a-z0-9][a-z0-9-]*$/u;
+/** What is wrong with a definition, as sentences; empty when nothing is. */
+export function collectPhiTourDefinitionErrors(definition) {
+    const errors = [];
+    if (!/^[^/\s]+(\/[^/\s]+)+$/u.test(definition.id)) {
+        errors.push(`Tour id "${definition.id}" is not namespaced as <module id>/<key>.`);
+    }
+    if (!Number.isInteger(definition.version) || definition.version < 1) {
+        errors.push(`Tour "${definition.id}" has version ${definition.version}; it must be a positive integer.`);
+    }
+    if (definition.steps.length === 0) {
+        errors.push(`Tour "${definition.id}" has no steps.`);
+    }
+    const keys = new Set();
+    for (const step of definition.steps) {
+        if (!TOUR_STEP_KEY_PATTERN.test(step.key)) {
+            errors.push(`Tour "${definition.id}" step "${step.key}" is not a lower-case key.`);
+        }
+        if (keys.has(step.key)) {
+            errors.push(`Tour "${definition.id}" names step "${step.key}" twice.`);
+        }
+        keys.add(step.key);
+        if (!step.title.trim()) {
+            errors.push(`Tour "${definition.id}" step "${step.key}" has no title.`);
+        }
+        if (step.target?.startsWith("controller:")) {
+            errors.push(`Tour "${definition.id}" step "${step.key}" points at a Controller, which draws nothing.`);
+        }
+    }
+    return errors;
+}
+/** The addresses a Tour points at, which the render has to draw with a live frame to be found. */
+export function readPhiTourTargets(tour) {
+    return (tour?.steps ?? []).flatMap((step) => (step.target ? [step.target] : []));
+}
+/** A Page Tour as it arrives in a Controller's config, or `null` for anything that is not one. */
+export function readPhiResolvedPageTour(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const record = value;
+    if (typeof record.id !== "string" || typeof record.version !== "number" || !Array.isArray(record.steps))
+        return null;
+    const labels = record.labels;
+    if (typeof labels?.next !== "string" || typeof labels.previous !== "string" || typeof labels.finish !== "string") {
+        return null;
+    }
+    return value;
+}

package/types/widget-runtime.d.ts

@@ -1,15 +1,9 @@
-import type { PhiShellTheme } from "../components/shell/shell-types";
-import type { PhiSiteFontSlots, PhiSiteRemSettings, PhiSiteThemeBrand, PhiSiteThemeContact, PhiSiteThemeRoot } from "./site-theme";
-import type { PhiThemeMode, PhiThemePalette } from "../theme/phi-theme-presets";
+import type { PhiThemeMode } from "../theme/phi-theme-presets";
 import type { PhiThemeModePreference } from "../theme/phi-theme-mode";
-import type { PhiThemeBlockSelection } from "../theme/phi-theme-composition";
-import type { PhiThemeDerivation } from "../theme/phi-theme-selection";
-import type { PhiControlShapeCorners } from "../theme/phi-control-shape";
-import type { PhiThemeButtons } from "../theme/phi-button-shadow";
-import type { PhiThemeTypography } from "../theme/phi-theme-typography";
+import type { PhiCmsAreaKey } from "@phis/contracts/cms";
 import type { PhiViewerAddonRoleClaim, PhiViewerGroupClaim, PhiViewerRoleClaim } from "./access";
+import type { PhiSiteLocaleOption, PhiSiteTheme } from "./site-config";
 import type { PhiControllerSignalAddress, PhiSignalAddress } from "./signals";
-export type PhiWidgetAreaKey = "public" | "app" | "admin" | "builder" | "editor" | "accounting";
 export type PhiWidgetViewerAccess = "public" | "authenticated";
 export type PhiWidgetThemeMode = PhiThemeMode;
 export type PhiBlockRuntimeSite = {
@@ -26,51 +20,49 @@ export type PhiBlockRuntimeSite = {
      * alternative was every caller carrying its own guess -- a hardcoded ["en","de","fr","es"] and a
      * hardcoded "en", neither of which an installation could depart from.
      */
-    availableLocales: Array<{
-        code: string;
-        label: string;
-    }>;
+    availableLocales: PhiSiteLocaleOption[];
     defaultLocale: string;
-    store?: {
+    /** The language the Site's own words are written in (`PhiSiteConfig.sourceLocale`). */
+    sourceLocale: string;
+    store: {
         enabled: boolean;
     };
     themeRevision?: {
         publishedRevisionId: number | null;
         workingDraftRevisionId: number | null;
     };
-    theme?: {
-        mode: PhiWidgetThemeMode;
-        /** Which Theme blocks the Site follows; `preset` remains the palette of a Theme written before. */
-        blocks?: PhiThemeBlockSelection | null;
-        /** The Set this Theme was derived from; a record for the Theme workspace, never read to render. */
-        derivedFrom?: PhiThemeDerivation | null;
-        preset?: string | null;
-        presetVersion?: number | null;
-        shape?: {
-            controls?: PhiControlShapeCorners | null;
-        } | null;
-        fonts?: PhiSiteFontSlots | null;
-        rem?: PhiSiteRemSettings | null;
-        brand?: PhiSiteThemeBrand;
-        contact?: PhiSiteThemeContact;
-        shell?: PhiShellTheme;
-        root?: PhiSiteThemeRoot | null;
-        palette?: PhiThemePalette | null;
-        style?: {
-            token?: Record<string, unknown>;
-        } | null;
-        buttons?: PhiThemeButtons | null;
-        typography?: PhiThemeTypography | null;
-        components?: Record<string, Record<string, unknown>> | null;
-    };
+    theme?: PhiBlockRuntimeSiteTheme;
+};
+/**
+ * The Site's Theme as a Widget reads it: the record the server answered, whole, with the mode decided.
+ *
+ * One type and not a second list of fields. The runtime copy used to name the Theme's fields by hand
+ * and the converter (`server-helpers/runtime.ts`) copied them by hand too, so `blocks`, `derivedFrom`,
+ * `shape`, `buttons` and `typography` were promised here and never arrived -- a Widget reading
+ * `runtime.site.theme.shape` got `undefined` from a type that said otherwise.
+ */
+export type PhiBlockRuntimeSiteTheme = Omit<PhiSiteTheme, "mode"> & {
+    mode: PhiWidgetThemeMode;
+};
+/**
+ * A Site as the server resolved it for a request: the parts a block may do without are answered.
+ *
+ * Stated once. The request context and the runtime loader each kept a copy of this with a hand-written
+ * Theme inside, three listings of one record that had drifted apart in which fields they knew.
+ */
+export type PhiResolvedBlockRuntimeSite = PhiBlockRuntimeSite & {
+    name: string;
+    hostname: string;
+    themeRevision: NonNullable<PhiBlockRuntimeSite["themeRevision"]>;
+    theme: PhiBlockRuntimeSiteTheme;
 };
 export type PhiBlockRuntimeLocale = {
     current: string;
 };
-export type PhiBlockRuntimeArea = PhiWidgetAreaKey;
+export type PhiBlockRuntimeArea = PhiCmsAreaKey;
 export type PhiBlockRuntimeViewer = {
     access: PhiWidgetViewerAccess;
-    resolvedArea?: PhiWidgetAreaKey | null;
+    resolvedArea?: PhiCmsAreaKey | null;
     roleClaims: readonly PhiViewerRoleClaim[];
     groupClaims: readonly PhiViewerGroupClaim[];
     /** Absent where a surface never carried them, which denies an `addon-roles` policy. */
@@ -104,6 +96,8 @@ export type PhiBlockRuntimeViewer = {
     profile?: {
         firstName?: string | null;
         lastName?: string | null;
+        /** The name a reader is shown -- a byline -- where it is not the first and last name. */
+        displayName?: string | null;
         companyName?: string | null;
     } | null;
 };

package/types.d.ts

@@ -2,7 +2,7 @@ export type { PhiCmsAreaPresetNode, PhiCmsContentWidgetNode, PhiCmsLayoutNode, P
 export * from "./types/cms-overlay";
 export type * from "./types/cms-container";
 export * from "./types/cms-instance-id";
-export { type PhiCmsAreaDefinition, type PhiCmsAreaOverlayPresetDescriptor, type PhiCmsAreaRouteMountDescriptor, type PhiCmsAreaShellCompositionSource, type PhiCmsAreaShellPresetBinding, type PhiCmsAreaShellPresetDescriptor, type PhiCmsDescriptorBuildContext, type PhiCmsNavigationAnchor, type PhiCmsNavigationAnchoredInjectionDescriptor, type PhiCmsNavigationAnchorPlacement, type PhiCmsNavigationBaseItemDescriptor, type PhiCmsNavigationCustomItem, type PhiCmsNavigationFolder, type PhiCmsNavigationFolderTarget, type PhiCmsNavigationInjectionDescriptor, type PhiCmsNavigationInjectionItemDescriptor, type PhiCmsNavigationItemOverride, type PhiCmsNavigationItemPlacement, type PhiCmsNavigationItemStanding, type PhiCmsNavigationKeyedInjectionDescriptor, type PhiCmsNavigationLabel, type PhiCmsNavigationSurfaceDescriptor, type PhiCmsPresetIdentity, type PhiCmsPresetSource, type PhiCmsRouteMountKey, type PhiCmsRouteMountReference, type PhiCmsRoutePresetBinding, type PhiCmsRoutePresetDescriptor, type PhiCmsThemeBlockBinding, type PhiCmsThemeBlockDescriptor, type PhiCmsThemeBlockKind, type PhiCmsThemeDescriptorContribution, type PhiCmsThemePresetBinding, type PhiCmsThemePresetDescriptor, type PhiRuntimeModuleId, } from "./types/cms-module-descriptors";
+export { type PhiCmsAreaDefinition, type PhiCmsAreaOverlayPresetDescriptor, type PhiCmsAreaShellCompositionSource, type PhiCmsAreaShellPresetBinding, type PhiCmsAreaShellPresetDescriptor, type PhiCmsDescriptorBuildContext, type PhiCmsNavigationAnchor, type PhiCmsNavigationAnchoredInjectionDescriptor, type PhiCmsNavigationAnchorPlacement, type PhiCmsNavigationBaseItemDescriptor, type PhiCmsNavigationCustomItem, type PhiCmsNavigationFolder, type PhiCmsNavigationFolderTarget, type PhiCmsNavigationInjectionDescriptor, type PhiCmsNavigationInjectionItemDescriptor, type PhiCmsNavigationItemOverride, type PhiCmsNavigationItemPlacement, type PhiCmsNavigationItemStanding, type PhiCmsNavigationKeyedInjectionDescriptor, type PhiCmsNavigationLabel, type PhiCmsNavigationSurfaceDescriptor, type PhiCmsPresetIdentity, type PhiCmsPresetSource, type PhiCmsRoutePresetBinding, type PhiCmsRoutePresetDescriptor, type PhiCmsThemeBlockBinding, type PhiCmsThemeBlockDescriptor, type PhiCmsThemeBlockKind, type PhiCmsThemeDescriptorContribution, type PhiCmsThemePresetBinding, type PhiCmsThemePresetDescriptor, type PhiRuntimeModuleId, } from "./types/cms-module-descriptors";
 export type { expandPhiBorderRadiusConfig, mergePhiBorderWidgetConfig, mergePhiCmsConfigValues, mergePhiPaddingWidgetConfig, normalizePhiPaddingWidgetConfig, PhiCmsBorderWidgetConfig, PhiCmsPaddingWidgetConfig, PhiCmsPluginConfigBase, PhiCmsRenderableBlockConfigBase, } from "./types/cms-config";
 export type { readPhiCmsBorderWidgetConfig } from "./types/cms-border-config";
 export type { PHI_CMS_BORDER_SOURCES, PhiCmsBorderSource, readPhiCmsBorderSource, resolvePhiCmsBorderSource, } from "./types/cms-border-source";
@@ -42,6 +42,7 @@ export type * from "./types/site-theme";
 export * from "./types/server-capabilities";
 export * from "./types/core-runtime-controller";
 export * from "./types/signals";
+export * from "./types/tours";
 export type { PhiCmsWidgetConfigBase } from "./components/widgets/config/parser-primitives";
 export * from "./components/widgets/config/control-signal-config";
 export type * from "./components/widgets/config/background";

package/types.js

@@ -21,4 +21,6 @@ export * from "./types/runtime-module-locale";
 export * from "./types/server-capabilities";
 export * from "./types/core-runtime-controller";
 export * from "./types/signals";
+// The Tour Controller's address and the Tour definition shape, for a Module that brings its own Tour.
+export * from "./types/tours";
 export * from "./components/widgets/config/control-signal-config";

package/widget-config.d.ts

@@ -5,5 +5,6 @@
  * expects. Without these a Module package would have to reproduce that base parser, which forks contract
  * logic into every package that ships a Widget.
  */
-export { readBoolean, readCssSize, readInteger, readNavItems, readNumber, readRenderableBlockConfig, readRenderableBlockSize, readString, } from "./components/widgets/config/parser-primitives";
+export { readBoolean, readCssSize, readInteger, readNavItems, readNumber, readRenderableBlockConfig, readString, } from "./components/widgets/config/parser-primitives";
 export type { PhiCmsWidgetConfigBase } from "./components/widgets/config/parser-primitives";
+export { normalizePhiRenderableBlockResponsiveSize, normalizePhiRenderableBlockSize, readPhiResponsiveLength, } from "./helpers/renderable-block-normalizers";

package/widget-config.js

@@ -5,4 +5,6 @@
  * expects. Without these a Module package would have to reproduce that base parser, which forks contract
  * logic into every package that ships a Widget.
  */
-export { readBoolean, readCssSize, readInteger, readNavItems, readNumber, readRenderableBlockConfig, readRenderableBlockSize, readString, } from "./components/widgets/config/parser-primitives";
+export { readBoolean, readCssSize, readInteger, readNavItems, readNumber, readRenderableBlockConfig, readString, } from "./components/widgets/config/parser-primitives";
+/* A block's size and lengths are read where every other reader of a block reads them (D1). */
+export { normalizePhiRenderableBlockResponsiveSize, normalizePhiRenderableBlockSize, readPhiResponsiveLength, } from "./helpers/renderable-block-normalizers";

package/components/layouts/clients/phi-flex-vertical-layout-client.d.ts

@@ -1,10 +0,0 @@
-import { type CSSProperties, type ReactNode } from "react";
-import { type PhiBaseLayoutProps } from "../phi-layout-view-model";
-import type { PhiAnchorWidgetPlacement } from "../../controls/phi-anchor-control-contract";
-export type PhiFlexVerticalLayoutProps = Omit<PhiBaseLayoutProps, "slots"> & {
-    slots: ReactNode[];
-    gap?: CSSProperties["gap"];
-    editSlotAnchor?: PhiAnchorWidgetPlacement | null;
-    style?: CSSProperties;
-};
-export declare function PhiFlexVerticalLayout({ slots, ...layoutProps }: PhiFlexVerticalLayoutProps): import("react").JSX.Element;

package/components/layouts/clients/phi-flex-vertical-layout-client.js

@@ -1,133 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import {} from "react";
-import { normalizePhiCssSize, resolvePhiFlexAxisAlignment, phiPlacementFromWord, resolvePhiSlotPlacementMargins, } from "../phi-layout-contract";
-import { resolvePhiLayoutSlotChildSizing } from "./phi-layout-anchored-overlay";
-import { resolvePhiLayoutDefaults } from "../../../helpers/cms-layout-defaults";
-import { resolvePhiBaseLayoutChrome, resolvePhiBaseLayoutSlotStates, } from "../phi-layout-view-model";
-import { isPhiLayoutAuthoringRender, phiLayoutDebugLayerMarker, phiLayoutSlotClassName, phiLayoutSlotContentMarker, } from "../../../helpers/layout-authoring-markers";
-const PHI_FLEX_VERTICAL_LAYOUT_DEFAULTS = resolvePhiLayoutDefaults("verticalflex");
-export function PhiFlexVerticalLayout({ slots, ...layoutProps }) {
-    // Named fields rather than the rest object: handing the compiler a whole rest object makes every
-    // value later destructured out of it look like it may change, which costs the component its memoization.
-    const isAuthoringRender = isPhiLayoutAuthoringRender({
-        editSlotAction: layoutProps.editSlotAction,
-        editSlotLabels: layoutProps.editSlotLabels,
-        capabilities: layoutProps.capabilities,
-        renderMode: layoutProps.renderMode,
-    });
-    const { layoutKind = "verticalflex", gap = PHI_FLEX_VERTICAL_LAYOUT_DEFAULTS.gap, editSlotAnchor, renderMode, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, background, backgroundLayer, borderSource, border, borderRadius, effect, shadow, editSlotAction, editRenderInsertControl, editSlotLabels, style, labelEnd, } = layoutProps;
-    const resolvedVertical = true;
-    const resolvedSlotStates = resolvePhiBaseLayoutSlotStates(slots.length, layoutProps.initialSlotStates);
-    const resolvedGap = normalizePhiCssSize(gap) ?? PHI_FLEX_VERTICAL_LAYOUT_DEFAULTS.gap;
-    const resolvedRenderMode = renderMode ?? "live";
-    const isEditMode = resolvedRenderMode === "editor";
-    const { style: resolvedLayoutStyle, hasExplicitLayoutBackground, } = resolvePhiBaseLayoutChrome({
-        labelEnd,
-        padding,
-        paddingTop,
-        paddingRight,
-        paddingBottom,
-        paddingLeft,
-        background,
-        borderSource,
-        border,
-        borderRadius,
-        effect,
-        shadow,
-    });
-    const resolvedFlowAlignment = resolvePhiFlexAxisAlignment(editSlotAnchor, resolvedVertical);
-    function isRenderableSlotChild(child) {
-        return child !== null && child !== undefined && child !== false;
-    }
-    const renderSlotChild = (child, index) => {
-        const slotState = resolvedSlotStates[index] ?? "expanded";
-        if (slotState === "hidden") {
-            return null;
-        }
-        const slotSizing = resolvePhiLayoutSlotChildSizing(child);
-        const shouldFillMainAxis = slotSizing.stretchesBlock;
-        const shouldFillCrossAxis = slotSizing.stretchesInline;
-        return (_jsx("div", { className: phiLayoutSlotClassName(isAuthoringRender), "data-phi-layout-has-content": phiLayoutSlotContentMarker(isAuthoringRender, true), style: {
-                flexGrow: shouldFillMainAxis ? 1 : 0,
-                flexShrink: shouldFillMainAxis ? 1 : 0,
-                flexBasis: shouldFillMainAxis ? "auto" : "auto",
-                ...(slotState === "collapsed"
-                    ? {
-                        width: 0,
-                        minWidth: 0,
-                        maxWidth: 0,
-                        height: 0,
-                        minHeight: 0,
-                        maxHeight: 0,
-                        flexBasis: 0,
-                        flexGrow: 0,
-                        flexShrink: 0,
-                        overflow: "hidden",
-                        opacity: 0,
-                        pointerEvents: "none",
-                    }
-                    : {}),
-                width: shouldFillCrossAxis ? "100%" : undefined,
-                height: shouldFillMainAxis ? "100%" : undefined,
-                minWidth: 0,
-                minHeight: 0,
-                alignSelf: shouldFillCrossAxis ? "stretch" : undefined,
-                display: "flex",
-                flexDirection: "column",
-                /*
-                 * The slot carries the Layout's own cross-axis alignment, because the slot is scaffolding and
-                 * the anchor is about the content. A slot is as wide as what it holds wants to be, and a child
-                 * that caps its width -- a column of copy at a readable measure -- is narrower than that: it
-                 * then stands at the left edge of a centred slot, which reads as "not centred" and is.
-                 *
-                 * Except where the child fills, which has to be stretched: `width: 100%` inside a shrink-to-fit
-                 * box is circular and resolves to zero, and a centred flex item is shrink-to-fit. That is not
-                 * a reason to give up the placement, though -- a filling child that also caps itself leaves
-                 * room over, and the placement margins put it in the middle of that room
-                 * instead. Stretching and placing are two jobs, and `align-items` can only do one of them.
-                 */
-                alignItems: shouldFillCrossAxis ? "stretch" : resolvedFlowAlignment.alignItems,
-                ...resolvePhiSlotPlacementMargins({
-                    inline: shouldFillCrossAxis ? phiPlacementFromWord(resolvedFlowAlignment.alignItems) : null,
-                    block: null,
-                }),
-            }, children: child }, `content-${index}`));
-    };
-    const renderableSlots = slots
-        .map((child, index) => ({ child, index }))
-        .filter(({ child, index }) => isRenderableSlotChild(child) && (resolvedSlotStates[index] ?? "expanded") !== "hidden");
-    const contentChildren = renderableSlots.map(({ child, index }) => renderSlotChild(child, index));
-    const insertAfterSlotIndex = slots.length;
-    const insertButton = isEditMode && editSlotAction && editRenderInsertControl ? (_jsx("div", { className: phiLayoutSlotClassName(isAuthoringRender), "data-phi-layout-has-content": phiLayoutSlotContentMarker(isAuthoringRender, false), style: {
-            flexGrow: 0,
-            flexShrink: 0,
-            flexBasis: "auto",
-            minWidth: 0,
-            minHeight: 0,
-        }, children: editRenderInsertControl({
-            presentation: "inline",
-            slotIndex: insertAfterSlotIndex,
-            label: editSlotLabels?.[insertAfterSlotIndex],
-            onInsert: (targetSlotIndex) => editSlotAction(targetSlotIndex, {
-                defaultPickSection: "widget",
-                allowWidgetSection: true,
-                slotIndex: targetSlotIndex,
-            }),
-        }) }, "insert")) : null;
-    const resolvedStyle = {
-        position: "relative",
-        ...resolvedLayoutStyle,
-        minWidth: 0,
-        minHeight: 0,
-        ...style,
-    };
-    return (_jsxs("div", { "data-layout-kind": layoutKind, "data-layout-axis": "vertical", className: "phi-layout", "data-phi-block-render-mode": resolvedRenderMode, "data-phi-layout-debug-layer": phiLayoutDebugLayerMarker(isAuthoringRender), "data-phi-layout-has-explicit-layout-background": hasExplicitLayoutBackground ? "true" : "false", style: {
-            display: "flex",
-            flexDirection: "column",
-            alignItems: resolvedFlowAlignment.alignItems,
-            justifyContent: resolvedFlowAlignment.justifyContent,
-            flexWrap: "nowrap",
-            gap: resolvedGap,
-            ...resolvedStyle,
-        }, children: [backgroundLayer, contentChildren, insertButton] }));
-}

package/components/root/phi-root-rem-provider.d.ts

@@ -1,7 +0,0 @@
-import type { ReactNode } from "react";
-type PhiRootRemProviderProps = {
-    rootValue: number;
-    children: ReactNode;
-};
-export declare function PhiRootRemProvider({ rootValue, children }: PhiRootRemProviderProps): import("react").JSX.Element;
-export {};

package/components/root/phi-root-rem-provider.js

@@ -1,14 +0,0 @@
-"use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { px2remTransformer, StyleProvider } from "@ant-design/cssinjs";
-function resolveFinitePositiveNumber(value, fallback) {
-    return Number.isFinite(value) && value > 0 ? value : fallback;
-}
-export function PhiRootRemProvider({ rootValue, children }) {
-    const transformer = px2remTransformer({
-        rootValue: resolveFinitePositiveNumber(rootValue, 16),
-        precision: 5,
-        mediaQuery: false,
-    });
-    return _jsx(StyleProvider, { transformers: [transformer], children: children });
-}

package/components/widgets/label-sets/news.d.ts

@@ -1,9 +0,0 @@
-import "server-only";
-import { type PhiGlobalTranslatorOptions } from "../../../gateway/tr";
-export declare function getPhiNewsListLabels(options: PhiGlobalTranslatorOptions): Promise<{
-    emptyTitle: string;
-    emptyText: string;
-    unavailable: string;
-    readMore: string;
-}>;
-export type PhiNewsListLabels = Awaited<ReturnType<typeof getPhiNewsListLabels>>;