@phis/ui 0.1.0

package/components/tables/phi-plain-table.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import styles from "./phi-plain-table.module.css";
+/**
+ * A table to read, not to work with.
+ *
+ * Markdown tables and other content that only shows rows use this rather than `PhiTableControl`. The
+ * Control carries sorting, pagination, inline editors for every column kind and drag reordering, and a
+ * page that renders it pays for all of them; this is a `<table>` and a stylesheet, with nothing to
+ * hydrate. It holds no hooks and no directive, so a Server Component can render it as well.
+ *
+ * Styled from Ant Design's CSS variables, so it follows the Theme and the colour scheme without reading
+ * a token in JavaScript. One look for now -- a line under the head and between rows; the presentation
+ * variants are to be shared with the Table Control once that has them.
+ */
+export function PhiPlainTable({ columns, rows, }) {
+    return (_jsx("div", { className: styles.scroll, children: _jsxs("table", { className: styles.table, children: [_jsx("thead", { children: _jsx("tr", { children: columns.map((column) => (_jsx("th", { scope: "col", style: column.align ? { textAlign: column.align } : undefined, children: column.title }, column.key))) }) }), _jsx("tbody", { children: rows.map((row) => (_jsx("tr", { children: columns.map((column, columnIndex) => (_jsx("td", { style: column.align ? { textAlign: column.align } : undefined, children: row.cells[columnIndex] ?? null }, column.key))) }, row.key))) })] }) }));
+}

package/components/tables/phi-plain-table.module.css

@@ -0,0 +1,34 @@
+/* Wide tables scroll inside their own box instead of widening the Page. */
+.scroll {
+  width: 100%;
+  overflow-x: auto;
+}
+
+.table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: var(--ant-font-size);
+  line-height: var(--ant-line-height);
+  color: var(--ant-color-text);
+}
+
+.table th,
+.table td {
+  padding: var(--ant-padding-xs) var(--ant-padding-sm);
+  text-align: start;
+  vertical-align: top;
+}
+
+.table th {
+  font-weight: var(--ant-font-weight-strong);
+  color: var(--ant-color-text-heading);
+  border-block-end: 1px solid var(--ant-color-border-secondary);
+}
+
+.table td {
+  border-block-end: 1px solid var(--ant-color-split);
+}
+
+.table tbody tr:last-child td {
+  border-block-end: none;
+}

package/components/trees/client/phi-tree-binding.d.ts

@@ -0,0 +1,35 @@
+import type { PhiTreeNodeIdentity, PhiTreeProviderMutationRequest, PhiTreeProviderMutationResult, PhiTreeQuery, PhiTreeQueryValue, PhiTreeSourceBinding } from "../../../types/tree-widget";
+import { PhiTreeProviderError } from "../../../types/tree-widget";
+type TreeNode = Record<string, unknown>;
+type MutationInput = PhiTreeProviderMutationRequest extends infer TRequest ? TRequest extends PhiTreeProviderMutationRequest ? Omit<TRequest, "resourceKey" | "params" | "signal"> : never : never;
+export declare function usePhiTreeBinding({ source, initialQuery, defaultExpandedNodeIdentities, defaultExpandAll, }: {
+    source: PhiTreeSourceBinding | null;
+    initialQuery?: PhiTreeQuery;
+    defaultExpandedNodeIdentities?: readonly PhiTreeNodeIdentity[];
+    defaultExpandAll?: boolean;
+}): {
+    provider: import("../../../runtime-data-provider-client").PhiTreeProviderRegistration | null;
+    resource: import("../../../types").PhiTreeProviderResourceDescriptor | null;
+    bindingError: string | null;
+    query: PhiTreeQuery;
+    setQuery: import("react").Dispatch<import("react").SetStateAction<PhiTreeQuery>>;
+    nodes: readonly TreeNode[];
+    loading: boolean;
+    error: PhiTreeProviderError | null;
+    selectedNodeIdentities: readonly PhiTreeNodeIdentity[];
+    setSelectedNodeIdentities: import("react").Dispatch<import("react").SetStateAction<readonly PhiTreeNodeIdentity[]>>;
+    checkedNodeIdentities: readonly PhiTreeNodeIdentity[];
+    setCheckedNodeIdentities: import("react").Dispatch<import("react").SetStateAction<readonly PhiTreeNodeIdentity[]>>;
+    expandedNodeIdentities: readonly PhiTreeNodeIdentity[];
+    setExpandedNodeIdentities: import("react").Dispatch<import("react").SetStateAction<readonly PhiTreeNodeIdentity[]>>;
+    reload: () => void;
+    commitField: (nodeIdentity: PhiTreeNodeIdentity, fieldKey: string, proposedValue: unknown) => Promise<PhiTreeProviderMutationResult>;
+    executeAction: (actionKey: string, nodeIdentity?: PhiTreeNodeIdentity | null, actionValue?: PhiTreeQueryValue | Record<string, unknown>) => Promise<PhiTreeProviderMutationResult>;
+    moveNode: (request: Omit<Extract<MutationInput, {
+        kind: "node-move";
+    }>, "kind">) => Promise<PhiTreeProviderMutationResult>;
+    drop: (request: Omit<Extract<MutationInput, {
+        kind: "drop";
+    }>, "kind">) => Promise<PhiTreeProviderMutationResult>;
+};
+export {};

package/components/trees/client/phi-tree-binding.js

@@ -0,0 +1,206 @@
+"use client";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { PhiTreeProviderError, readPhiTreeProviderError, readPhiTreeProviderMutationResult, readPhiTreeProviderQueryResult, } from "../../../types/tree-widget";
+import { validatePhiTableProviderFieldValue } from "../../../types/table-widget";
+import { usePhiTreeProvider } from "../../widgets/client/shared/phi-tree-provider";
+function readPath(value, path) {
+    return path.split(".").reduce((current, key) => current && typeof current === "object" ? current[key] : undefined, value);
+}
+function patchNode(nodes, identityPath, identity, patch) {
+    return nodes.map((node) => String(readPath(node, identityPath)) === String(identity) ? { ...node, ...patch } : node);
+}
+function moveNodeOptimistically(nodes, identityPath, parentPath, request) {
+    const movedIndex = nodes.findIndex((node) => String(readPath(node, identityPath)) === String(request.movedNodeIdentity));
+    if (movedIndex < 0)
+        return nodes;
+    const moved = { ...nodes[movedIndex], [parentPath]: request.targetParentNodeIdentity };
+    const remaining = nodes.filter((_, index) => index !== movedIndex);
+    let insertIndex = request.beforeNodeIdentity == null ? -1 : remaining.findIndex((node) => String(readPath(node, identityPath)) === String(request.beforeNodeIdentity));
+    if (insertIndex < 0 && request.afterNodeIdentity != null) {
+        const afterIndex = remaining.findIndex((node) => String(readPath(node, identityPath)) === String(request.afterNodeIdentity));
+        insertIndex = afterIndex < 0 ? -1 : afterIndex + 1;
+    }
+    if (insertIndex < 0) {
+        const siblingIndexes = remaining.flatMap((node, index) => String(readPath(node, parentPath)) === String(request.targetParentNodeIdentity) ? [index] : []);
+        insertIndex = siblingIndexes.length ? siblingIndexes.at(-1) + 1 : remaining.length;
+    }
+    return [...remaining.slice(0, insertIndex), moved, ...remaining.slice(insertIndex)];
+}
+function validateTree(nodes, identityPath, parentPath) {
+    const identities = new Set();
+    for (const node of nodes) {
+        const identity = readPath(node, identityPath);
+        if (typeof identity !== "string" && typeof identity !== "number")
+            return `Tree node is missing identity field "${identityPath}".`;
+        if (identities.has(String(identity)))
+            return `Tree Provider returned duplicate node identity "${String(identity)}".`;
+        identities.add(String(identity));
+    }
+    for (const node of nodes) {
+        const parent = readPath(node, parentPath);
+        if (parent != null && !identities.has(String(parent)))
+            return `Tree node references unknown parent "${String(parent)}".`;
+        const seen = new Set();
+        let current = readPath(node, identityPath);
+        while (current != null) {
+            const key = String(current);
+            if (seen.has(key))
+                return `Tree Provider returned a hierarchy cycle at "${key}".`;
+            seen.add(key);
+            const currentNode = nodes.find((candidate) => String(readPath(candidate, identityPath)) === key);
+            current = currentNode ? readPath(currentNode, parentPath) : null;
+        }
+    }
+    return null;
+}
+export function usePhiTreeBinding({ source, initialQuery = {}, defaultExpandedNodeIdentities = [], defaultExpandAll = false, }) {
+    const { provider, resource, bindingError } = usePhiTreeProvider(source);
+    const [query, setQuery] = useState(initialQuery);
+    const [nodes, setNodes] = useState([]);
+    const nodesRef = useRef(nodes);
+    const [loading, setLoading] = useState(Boolean(source));
+    const [error, setError] = useState(null);
+    const [selectedNodeIdentities, setSelectedNodeIdentities] = useState([]);
+    const [checkedNodeIdentities, setCheckedNodeIdentities] = useState([]);
+    const [expandedNodeIdentities, setExpandedNodeIdentities] = useState(defaultExpandedNodeIdentities);
+    const [refreshRevision, setRefreshRevision] = useState(0);
+    const expandedInitialSnapshot = useRef(false);
+    const sourceKey = useMemo(() => JSON.stringify(source), [source]);
+    useEffect(() => { nodesRef.current = nodes; }, [nodes]);
+    useEffect(() => {
+        expandedInitialSnapshot.current = false;
+        let cancelled = false;
+        queueMicrotask(() => {
+            if (cancelled)
+                return;
+            setNodes([]);
+            setSelectedNodeIdentities([]);
+            setCheckedNodeIdentities([]);
+            setExpandedNodeIdentities(defaultExpandedNodeIdentities);
+            setQuery(initialQuery);
+        });
+        return () => { cancelled = true; };
+    }, [defaultExpandedNodeIdentities, initialQuery, sourceKey]);
+    useEffect(() => {
+        if (!source || !provider || !resource)
+            return;
+        const controller = new AbortController();
+        queueMicrotask(() => {
+            if (!controller.signal.aborted) {
+                setLoading(true);
+                setError(null);
+            }
+        });
+        void provider.query({ resourceKey: source.resourceKey, query, params: source.params, signal: controller.signal })
+            .then((value) => {
+            if (controller.signal.aborted)
+                return;
+            const result = readPhiTreeProviderQueryResult(value);
+            if (!result)
+                throw new PhiTreeProviderError("invalid-query-result", "Tree Provider returned an invalid query result.");
+            const validationError = validateTree(result.nodes, resource.nodeIdentityPath, resource.parentNodeIdentityPath);
+            if (validationError)
+                throw new PhiTreeProviderError("invalid-tree", validationError);
+            nodesRef.current = result.nodes;
+            setNodes(result.nodes);
+            if (defaultExpandAll && !expandedInitialSnapshot.current) {
+                expandedInitialSnapshot.current = true;
+                setExpandedNodeIdentities(result.nodes.flatMap((node) => {
+                    const identity = readPath(node, resource.nodeIdentityPath);
+                    return identity == null ? [] : [identity];
+                }));
+            }
+            setLoading(false);
+        })
+            .catch((queryError) => {
+            if (!controller.signal.aborted) {
+                setNodes([]);
+                setLoading(false);
+                setError(readPhiTreeProviderError(queryError));
+            }
+        });
+        return () => controller.abort();
+    }, [defaultExpandAll, provider, query, refreshRevision, resource, source]);
+    const mutate = useCallback(async (request, optimisticNodes) => {
+        if (bindingError || !provider || !resource || !source) {
+            throw new PhiTreeProviderError("provider-unavailable", bindingError ?? "Tree Provider is unavailable.");
+        }
+        if (!provider.mutate)
+            throw new PhiTreeProviderError("provider-read-only", `Tree Provider "${source.providerKey}" is read-only.`);
+        const previous = nodesRef.current;
+        if (optimisticNodes) {
+            nodesRef.current = optimisticNodes;
+            setNodes(optimisticNodes);
+        }
+        try {
+            const rawResult = await provider.mutate({ ...request, resourceKey: source.resourceKey, params: source.params, signal: new AbortController().signal });
+            const result = readPhiTreeProviderMutationResult(rawResult);
+            if (!result)
+                throw new PhiTreeProviderError("invalid-mutation-result", "Tree Provider returned an invalid mutation result.");
+            if (result.status === "rejected") {
+                nodesRef.current = previous;
+                setNodes(previous);
+                setError(new PhiTreeProviderError(result.errorCode ?? "mutation-rejected", result.message ?? "Tree change was rejected."));
+            }
+            else if (request.kind === "field") {
+                const canonicalValue = result.canonicalValue === undefined ? request.proposedValue : result.canonicalValue;
+                const next = patchNode(nodesRef.current, resource.nodeIdentityPath, request.nodeIdentity, {
+                    [request.fieldKey]: canonicalValue,
+                    ...(result.nodePatch ?? {}),
+                });
+                nodesRef.current = next;
+                setNodes(next);
+            }
+            if (result.invalidation !== "none")
+                setRefreshRevision((current) => current + 1);
+            return result;
+        }
+        catch (mutationError) {
+            nodesRef.current = previous;
+            setNodes(previous);
+            const nextError = readPhiTreeProviderError(mutationError);
+            setError(nextError);
+            throw nextError;
+        }
+    }, [bindingError, provider, resource, source]);
+    const commitField = useCallback(async (nodeIdentity, fieldKey, proposedValue) => {
+        if (!resource)
+            throw new PhiTreeProviderError("resource-unavailable", "Tree resource is unavailable.");
+        const field = resource.fields.find((candidate) => candidate.key === fieldKey);
+        if (!field?.mutable)
+            throw new PhiTreeProviderError("field-read-only", `Tree field "${fieldKey}" is read-only.`);
+        const node = nodesRef.current.find((candidate) => String(readPath(candidate, resource.nodeIdentityPath)) === String(nodeIdentity));
+        // A node that offers its own choices for the field accepts only one of them.
+        const validationError = validatePhiTableProviderFieldValue(field, proposedValue, node);
+        if (validationError)
+            throw new PhiTreeProviderError("invalid-field-value", validationError.replaceAll("Table field", "Tree field"));
+        const originalValue = node ? readPath(node, fieldKey) : undefined;
+        return mutate({ kind: "field", nodeIdentity, fieldKey, originalValue, proposedValue }, patchNode(nodesRef.current, resource.nodeIdentityPath, nodeIdentity, { [fieldKey]: proposedValue }));
+    }, [mutate, resource]);
+    const executeAction = useCallback((actionKey, nodeIdentity, actionValue) => mutate({ kind: "action", actionKey, nodeIdentity, selectedNodeIdentities, actionValue, query }), [mutate, query, selectedNodeIdentities]);
+    const moveNode = useCallback((request) => {
+        if (!resource)
+            throw new PhiTreeProviderError("resource-unavailable", "Tree resource is unavailable.");
+        let ancestor = request.targetParentNodeIdentity;
+        while (ancestor != null) {
+            if (String(ancestor) === String(request.movedNodeIdentity)) {
+                throw new PhiTreeProviderError("invalid-node-move", "A Tree node cannot be moved into itself or one of its descendants.");
+            }
+            const ancestorNode = nodesRef.current.find((node) => String(readPath(node, resource.nodeIdentityPath)) === String(ancestor));
+            ancestor = ancestorNode ? readPath(ancestorNode, resource.parentNodeIdentityPath) : null;
+        }
+        const optimistic = moveNodeOptimistically(nodesRef.current, resource.nodeIdentityPath, resource.parentNodeIdentityPath, request);
+        return mutate({ kind: "node-move", ...request }, optimistic);
+    }, [mutate, resource]);
+    const drop = useCallback((request) => mutate({ kind: "drop", ...request }), [mutate]);
+    return {
+        provider, resource, bindingError,
+        query, setQuery,
+        nodes, loading, error,
+        selectedNodeIdentities, setSelectedNodeIdentities,
+        checkedNodeIdentities, setCheckedNodeIdentities,
+        expandedNodeIdentities, setExpandedNodeIdentities,
+        reload: () => setRefreshRevision((current) => current + 1),
+        commitField, executeAction, moveNode, drop,
+    };
+}

package/components/widgets/area-menu-items.d.ts

@@ -0,0 +1,16 @@
+import { type PhiAccessViewer } from "../../types/access";
+import type { PhiAreaMenuItem } from "../../plugins/runtime-modules/core/widgets/area-menu/client";
+/**
+ * The Area menu asks the same question the Area routing asks, with the same tool: every declared
+ * Area, filtered by `canPhiViewerAccess` against its own `accessPolicy`.
+ *
+ * It must not re-derive visibility from base roles. That answered the question a second way and
+ * disagreed with the policies — a Developer holds `Structure authoring`, `Content editing` and
+ * `Accounting`, yet saw neither Builder nor Editor nor Accounting. And it must not consult
+ * `viewer.resolvedArea`, which ACCESS.md defines as a landing destination, not an authorization
+ * boundary; in the old menu it papered over the incomplete role check for one Area per viewer.
+ *
+ * Public is the Area a viewer is already in rather than one to switch to, so it is not listed. The
+ * order follows the Area declarations, the one source this list has.
+ */
+export declare function buildPhiVisibleAreaMenuItems(viewer: PhiAccessViewer): PhiAreaMenuItem[];

package/components/widgets/area-menu-items.js

@@ -0,0 +1,26 @@
+import { resolvePhiCmsAreaLabel } from "../../constants/cms-areas";
+import { PHI_ALL_RUNTIME_AREA_DEFINITIONS } from "../../plugins/runtime-modules/area-definitions";
+import { canPhiViewerAccess } from "../../types/access";
+/**
+ * The Area menu asks the same question the Area routing asks, with the same tool: every declared
+ * Area, filtered by `canPhiViewerAccess` against its own `accessPolicy`.
+ *
+ * It must not re-derive visibility from base roles. That answered the question a second way and
+ * disagreed with the policies — a Developer holds `Structure authoring`, `Content editing` and
+ * `Accounting`, yet saw neither Builder nor Editor nor Accounting. And it must not consult
+ * `viewer.resolvedArea`, which ACCESS.md defines as a landing destination, not an authorization
+ * boundary; in the old menu it papered over the incomplete role check for one Area per viewer.
+ *
+ * Public is the Area a viewer is already in rather than one to switch to, so it is not listed. The
+ * order follows the Area declarations, the one source this list has.
+ */
+export function buildPhiVisibleAreaMenuItems(viewer) {
+    return PHI_ALL_RUNTIME_AREA_DEFINITIONS
+        .filter((definition) => definition.area !== "public")
+        .filter((definition) => canPhiViewerAccess(viewer, definition.accessPolicy))
+        .map((definition) => ({
+        key: definition.area,
+        label: resolvePhiCmsAreaLabel(definition.area),
+        href: `/${definition.area}`,
+    }));
+}

package/components/widgets/builder/command-toolbar-authoring-tools.d.ts

@@ -0,0 +1,5 @@
+import type { PhiCommandToolbarButtonConfig } from "../../../plugins/runtime-modules/core/widgets/command-toolbar/config";
+export declare function PhiCommandToolbarAuthoringTools({ buttons, onChange, }: {
+    buttons: readonly PhiCommandToolbarButtonConfig[];
+    onChange: (buttons: PhiCommandToolbarButtonConfig[]) => void;
+}): import("react").JSX.Element;

package/components/widgets/builder/command-toolbar-authoring-tools.js

@@ -0,0 +1,41 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ArrowDownOutlined, ArrowUpOutlined, DeleteOutlined, MenuOutlined, PlusOutlined, } from "@ant-design/icons";
+import { Flex, Space, Typography } from "antd";
+import { PhiButtonControl } from "../../controls/phi-button-control";
+import { PhiPopoverControl } from "../../controls/phi-popover-control";
+import { usePhiConfig } from "../../root/phi-config-provider";
+import { usePhiWidgetScaffoldPopup } from "../client/shared/phi-widget-scaffold-popup";
+function stopToolEvent(event) {
+    event.stopPropagation();
+}
+function createNextButton(buttons) {
+    const keys = new Set(buttons.map((button) => button.key));
+    let index = buttons.length + 1;
+    let key = `button${index}`;
+    while (keys.has(key)) {
+        index += 1;
+        key = `button${index}`;
+    }
+    return {
+        key,
+        label: `Button ${index}`,
+        emits: [{ capabilityId: "command", value: key }],
+    };
+}
+function moveButton(buttons, index, direction) {
+    const targetIndex = index + direction;
+    if (targetIndex < 0 || targetIndex >= buttons.length) {
+        return buttons;
+    }
+    const nextButtons = [...buttons];
+    [nextButtons[index], nextButtons[targetIndex]] = [nextButtons[targetIndex], nextButtons[index]];
+    return nextButtons;
+}
+export function PhiCommandToolbarAuthoringTools({ buttons, onChange, }) {
+    const { token } = usePhiConfig();
+    const popup = usePhiWidgetScaffoldPopup();
+    return (_jsxs(Space.Compact, { children: [_jsx("span", { onClick: stopToolEvent, onPointerDown: stopToolEvent, style: { display: "inline-flex" }, children: _jsx(PhiButtonControl, { type: "text", size: "small", ariaLabel: "Add button", tooltip: "Add button", icon: _jsx(PlusOutlined, {}), onClick: () => {
+                        onChange([...buttons, createNextButton(buttons)]);
+                    } }) }), _jsx(PhiPopoverControl, { trigger: "click", placement: "bottomRight", getPopupContainer: popup.getPopupContainer, rootClassName: popup.rootClassName, onOpenChange: popup.setOpen, content: (_jsx(Flex, { vertical: true, gap: token.paddingXXS, style: { minWidth: 240 }, onClick: stopToolEvent, onPointerDown: stopToolEvent, children: buttons.length === 0 ? (_jsx(Typography.Text, { type: "secondary", children: "No buttons" })) : buttons.map((button, index) => (_jsxs(Flex, { align: "center", gap: token.paddingXXS, children: [_jsx(Typography.Text, { ellipsis: true, style: { flex: "1 1 auto", minWidth: 0 }, children: button.label ?? button.actionKey ?? button.key }), _jsx(PhiButtonControl, { type: "text", size: "small", ariaLabel: `Move ${button.label ?? button.key} earlier`, disabled: index === 0, icon: _jsx(ArrowUpOutlined, {}), onClick: () => onChange([...moveButton(buttons, index, -1)]) }), _jsx(PhiButtonControl, { type: "text", size: "small", ariaLabel: `Move ${button.label ?? button.key} later`, disabled: index === buttons.length - 1, icon: _jsx(ArrowDownOutlined, {}), onClick: () => onChange([...moveButton(buttons, index, 1)]) }), _jsx(PhiButtonControl, { type: "text", size: "small", danger: true, ariaLabel: `Remove ${button.label ?? button.key}`, icon: _jsx(DeleteOutlined, {}), onClick: () => onChange(buttons.filter((_, candidateIndex) => candidateIndex !== index)) })] }, button.key))) })), children: _jsx("span", { onClick: stopToolEvent, onPointerDown: stopToolEvent, style: { display: "inline-flex" }, children: _jsx(PhiButtonControl, { type: "text", size: "small", ariaLabel: "Manage buttons", tooltip: "Manage buttons", disabled: buttons.length === 0, icon: _jsx(MenuOutlined, {}), onClick: () => undefined }) }) })] }));
+}

package/components/widgets/builder/icon-editor.d.ts

@@ -0,0 +1,10 @@
+import type { PhiCmsIconWidgetConfig } from "../../../plugins/runtime-modules/core/widgets/icon/config";
+import type { PhiCmsInstanceId } from "../../../types/cms-instance-id";
+export declare function PhiIconWidgetEditor({ blockId, config, }: {
+    blockId: PhiCmsInstanceId;
+    config: PhiCmsIconWidgetConfig;
+}): import("react").JSX.Element;
+export declare function PhiIconWidgetEditorTools({ config, onChange, }: {
+    config: PhiCmsIconWidgetConfig;
+    onChange: (patch: Partial<PhiCmsIconWidgetConfig>) => void;
+}): import("react").JSX.Element;

package/components/widgets/builder/icon-editor.js

@@ -0,0 +1,10 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { PhiIconWidgetClient } from "../../../plugins/runtime-modules/core/widgets/icon/client";
+import { PhiWidgetColorToolButton, PhiWidgetIconToolButton, } from "../client/shared/phi-widget-tool-buttons";
+export function PhiIconWidgetEditor({ blockId, config, }) {
+    return _jsx(PhiIconWidgetClient, { blockId: blockId, config: config });
+}
+export function PhiIconWidgetEditorTools({ config, onChange, }) {
+    return (_jsxs(_Fragment, { children: [_jsx(PhiWidgetIconToolButton, { value: config.icon ?? null, ariaLabel: "Icon widget icon", onChange: (icon) => onChange({ icon: icon ?? undefined }) }), _jsx(PhiWidgetColorToolButton, { value: config.color ?? null, ariaLabel: "Icon widget color", onChange: (color) => onChange({ color: color ?? undefined }) })] }));
+}

package/components/widgets/builder/internal-builder.d.ts

@@ -0,0 +1,22 @@
+import { type PhiStructureRegionWidgetConfig } from "../../../plugins/runtime-modules/builder/widgets/structure-region/config";
+export declare const PHI_STRUCTURE_REGION_WIDGET_BUILDER_PLUGIN: {
+    renderEditor: ({ widget }: import("../../../types").PhiCmsBuilderWidgetRenderArgs<PhiStructureRegionWidgetConfig>) => import("react").JSX.Element;
+    kind: "widget";
+    pluginKey: string;
+    typeKey: string;
+    title: string;
+    description: string;
+    category: "workspace";
+    iconFamily: string;
+    slotSizePolicy: "fill";
+    fields: ({
+        key: string;
+        type: "string";
+        label: string;
+    } | {
+        key: string;
+        type: "boolean";
+        label: string;
+    })[];
+    parseConfig: (raw: Record<string, unknown>) => PhiStructureRegionWidgetConfig;
+};

package/components/widgets/builder/internal-builder.js

@@ -0,0 +1,8 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { PHI_STRUCTURE_REGION_WIDGET_DEFINITION, } from "../../../plugins/runtime-modules/builder/widgets/structure-region/config";
+import { PhiWidgetEditorPlaceholder } from "./widget-editor-placeholder";
+export const PHI_STRUCTURE_REGION_WIDGET_BUILDER_PLUGIN = {
+    ...PHI_STRUCTURE_REGION_WIDGET_DEFINITION,
+    renderEditor: ({ widget }) => (_jsx(PhiWidgetEditorPlaceholder, { widget: widget, pluginTitle: PHI_STRUCTURE_REGION_WIDGET_DEFINITION.title, summary: "Builder editor placeholder for a structure region." })),
+};

package/components/widgets/builder/navigation-items.d.ts

@@ -0,0 +1,3 @@
+import { type PhiBuilderNavigationItem } from "../../../helpers/cms-navigation-catalog";
+import type { PhiNavItem } from "../../shell/shell-types";
+export declare function mapPhiBuilderNavigationItemsToNavItems(items: PhiBuilderNavigationItem[]): PhiNavItem[];

package/components/widgets/builder/navigation-items.js

@@ -0,0 +1,17 @@
+"use client";
+import {} from "../../../helpers/cms-navigation-catalog";
+export function mapPhiBuilderNavigationItemsToNavItems(items) {
+    return items.filter((item) => !item.hidden).map((item) => {
+        const children = mapPhiBuilderNavigationItemsToNavItems(item.children);
+        return {
+            key: item.id,
+            label: item.label,
+            ...(item.href?.trim() ? { href: item.href.trim() } : {}),
+            ...(item.icon ? { icon: item.icon } : {}),
+            ...(item.external === true ? { external: true } : {}),
+            ...(item.newTab === true ? { newTab: true } : {}),
+            ...(item.kind === "separator" ? { separator: true } : {}),
+            ...(children.length > 0 ? { children } : {}),
+        };
+    });
+}

package/components/widgets/builder/phi-static-options-picker.d.ts

@@ -0,0 +1,6 @@
+import type { PhiControlOption } from "../../controls/phi-control-options";
+export declare function PhiStaticOptionsToolButton({ options, disabled, onApply, }: {
+    options: readonly PhiControlOption[];
+    disabled?: boolean;
+    onApply: (options: PhiControlOption[]) => void;
+}): import("react").JSX.Element;