@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/screen-link-context.d.ts

@@ -0,0 +1,185 @@
+import { type ScreenRouteMap } from './screen-link-context-value';
+export * from './screen-link-context-value';
+export interface ResolvedScreenLink {
+    /** Site-relative href (`/`, `/company/about`), undefined when unresolvable. */
+    href?: string;
+    suppressNavigation: boolean;
+    /** True only on the static besigner canvas — interactions are inert. */
+    editorInert: boolean;
+    /**
+     * A screen id WAS authored and the routing map does not have it — the
+     * target is unpublished or deleted (AGL-1893).
+     *
+     * Distinct from "no href": the canvas and the preview withhold hrefs on
+     * purpose, and an element with no link at all never had one to lose.
+     * Only this flag means the author asked for a link that cannot exist, and
+     * only elements reading THIS may say so — see {@link isScreenLinkBroken}
+     * for why an absent or empty map is deliberately not "broken".
+     */
+    broken: boolean;
+}
+/**
+ * Whether an authored screen id points at nothing (AGL-1893).
+ *
+ * Unpublishing or deleting a screen is a normal authoring action, and until
+ * this existed nothing anywhere reported what it had just broken: a Tabs
+ * link to a retired screen shipped as a live-looking control that silently
+ * did nothing on `aglyn.com/changelog` and `/newsroom` for two days.
+ *
+ * The two "we cannot tell" cases are NOT broken, and the distinction is the
+ * whole safety of this predicate:
+ *
+ * - **no map** — a surface that renders canvas nodes without providing
+ *   `ScreenLinkContext` (an isolated spec, an embed) knows nothing about
+ *   the host's screens, and must not conclude that every link is dead;
+ * - **an empty map** — the same thing one beat earlier: the console's live
+ *   host subscription starts empty, and a moment of `{}` must not repaint a
+ *   whole navigation row as broken and then repaint it back.
+ *
+ * Both failure directions were weighed. Calling a live link broken hides or
+ * disables working navigation on a customer's site; calling a dead link fine
+ * leaves exactly the defect this issue is about. Only the first is
+ * unrecoverable from the visitor's side, so the doubt resolves that way.
+ */
+export declare function isScreenLinkBroken(screens: ScreenRouteMap | undefined, screenId: string | null | undefined): boolean;
+/**
+ * The extra option a Screen picker needs when its stored value matches none
+ * of the host's screens (AGL-1893).
+ *
+ * The console builds `SCREEN_SELECT` options from the routing map, so a
+ * value the map has lost — the retired `/blog` screen, say — matches
+ * nothing and the field renders EMPTY. Which reads, to the person looking
+ * at it, as "no link set". Meanwhile the element still behaves as linked:
+ * the strip is still a nav landmark, that tab is still skipped as
+ * "navigates", and the panel it would have revealed is still suppressed. So
+ * the one surface where this is repairable was also the one actively
+ * denying there was anything to repair.
+ *
+ * Returns the stored value UNCHANGED as the option's value: naming a dead
+ * target must not rewrite it, or opening the panel and pressing Save would
+ * quietly convert a recoverable reference into something else.
+ *
+ * Three shapes get named, because a Screen picker can legally hold any of
+ * them (AGL-1335 / AGL-1894 / AGL-2799): a screen reference whose screen is
+ * gone, a collection listing whose collection is gone, and a plain address
+ * typed in before the picker existed. The last is not broken — but it is
+ * just as invisible, and an author who cannot see it is the reason those
+ * links are not rename-safe yet.
+ */
+export declare function unavailableScreenLabel(screenId: string, screensKnown: boolean): string;
+export declare function unresolvedScreenOption(value: unknown, screens: ScreenRouteMap | undefined): {
+    value: string;
+    label: string;
+} | undefined;
+/** One target a link picker offers — see {@link screenLinkTargetOptions}. */
+export interface ScreenLinkTargetOption {
+    /**
+     * The routing-map key: a bare screen id, a collection listing's
+     * `collection:<id>`, or its feed's `feed:<id>`. Stored as it is in a screen
+     * slot, and through `formatScreenLinkValue` in a `Link`-typed prop.
+     */
+    value: string;
+    label: string;
+    kind: 'screen' | 'collection-listing' | 'feed';
+}
+/**
+ * What a picker calls one routing-map target, or `undefined` for a key the
+ * map does not hold — the label {@link screenLinkTargetOptions} gives it.
+ *
+ * A listing and a feed are labeled with their collection's name and address,
+ * like a screen, and marked as what they are IN the label rather than only by
+ * position: a closed picker shows the chosen label and nothing else, and
+ * "Blog (/blog)" there reads exactly like a screen named Blog. A feed borrows
+ * its collection's name, which is the only name it has (AGL-3119).
+ *
+ * An entry is never named here. A map holds only the entries a page
+ * references, under no label, so an entry is named by the search seam
+ * (`LinkTargetSearchContext`), which reads the entry itself.
+ */
+export declare function screenLinkTargetLabel(key: string, screens: ScreenRouteMap | undefined, labels: Record<string, string> | undefined): string | undefined;
+/**
+ * Everything a Screen picker offers, in the order it offers it (AGL-2799):
+ * the host's screens, then its content collections' listing pages, then
+ * their RSS feeds (AGL-3119).
+ *
+ * ONE builder for both pickers — the attributes panel's `SCREEN_SELECT` and
+ * the `Link`-typed prop picker. Each used to map the routing map into options
+ * by itself, so a target added to one list was missing from the other; and
+ * neither offered a collection's listing at all, which is how the drawer on
+ * aglyn.com came to link its blog as a typed `/blog`.
+ *
+ * Entries are left out even when the map holds some: they are searched, not
+ * listed, because a site's entries are far too many to read into a dropdown
+ * — see `LinkTargetSearchContext`.
+ *
+ * `order` keeps each picker's established screen order — by path in the
+ * attributes panel, by name in the prop picker — and the listings and feeds
+ * follow the screens in the same order.
+ */
+export declare function screenLinkTargetOptions(screens: ScreenRouteMap | undefined, labels: Record<string, string> | undefined, order?: 'path' | 'label'): ScreenLinkTargetOption[];
+/**
+ * Marks the element in the DOM. Present on the live site too, deliberately:
+ * a smoke pass can then find every dead control on a page with one selector
+ * instead of reading five different components' conditions.
+ */
+export declare const BROKEN_SCREEN_LINK_ATTR = "data-aglyn-broken-link";
+/** What the AUTHOR is told, on the one surface that can fix it. */
+export declare const BROKEN_SCREEN_LINK_MESSAGE: string;
+/**
+ * The editor-only outline. A warning ring rather than an error one: the
+ * screen may be deliberately unpublished and about to come back, and the
+ * page is not broken, one control on it is.
+ */
+export declare const BROKEN_SCREEN_LINK_SX: {
+    outline: string;
+    outlineColor: string;
+    outlineOffset: string;
+    borderRadius: number;
+};
+/**
+ * Props that make a dead screen link visible to its author (AGL-1893).
+ *
+ * The tooltip and the ring are `editorInert` only — that is the static
+ * besigner canvas, the one surface where the person who can fix this is
+ * looking at it. Preview deliberately does NOT get them: preview exists to
+ * show what visitors will see, and an authoring annotation painted into it
+ * is a lie of a different kind.
+ *
+ * The data attribute ships everywhere, canvas and live site alike.
+ */
+export declare function brokenScreenLinkProps(broken: boolean, editorInert: boolean): Record<string, unknown>;
+/**
+ * Link VALUE parsing AND resolution live in `./screen-link-value` —
+ * server-safe, because the where-used scan and the Markdown representation of
+ * a page both run on the server, and the `createContext` this module reaches
+ * keeps it out of the `@aglyn/aglyn/server` barrel (AGL-703, AGL-2740).
+ * Re-exported here so every existing importer, and the spec beside this file,
+ * keeps reaching them at the address they have always used.
+ */
+export { COLLECTION_LINK_VALUE_PREFIX, ENTRY_LINK_VALUE_PREFIX, EXTERNAL_HREF_PATTERN, FEED_LINK_VALUE_PREFIX, SAFE_HREF_PATTERN, SCREEN_LINK_VALUE_PREFIX, formatCollectionLinkValue, formatEntryLinkValue, formatFeedLinkValue, formatScreenLinkValue, linkTargetKind, nodesReferenceScreen, parseCollectionLinkValue, parseEntryLinkValue, parseFeedLinkValue, parseScreenLinkValue, resolveScreenHref, screenRoutesAnswerFor, splitLinkValue, type LinkTargetKind, } from './screen-link-value';
+/** What a linking element renders — see {@link useLinkTarget}. */
+export interface ResolvedLinkTarget extends ResolvedScreenLink {
+    /** The literal href in play once safety-checked, when no screen resolved. */
+    externalHref?: string;
+    /** True when `href` leaves the site — what "open in a new tab" may act on. */
+    leavesSite: boolean;
+}
+/**
+ * The single href a linking element should render, from the `screenId` +
+ * `href` pair every one of them declares (AGL-1335).
+ *
+ * Button, Screen Link, Link Box and Image each had the same four lines —
+ * resolve the id, safety-check the URL, prefer the id — which is three
+ * copies too many now that a `Link`-typed component prop can feed either
+ * slot with either shape. Hook-shaped because {@link useScreenLink} is;
+ * it is always called, so the hook order never depends on the values.
+ */
+export declare function useLinkTarget(screenId: string | null | undefined, href: string | null | undefined): ResolvedLinkTarget;
+/**
+ * Resolves a screen id to its current href. Memoized on the routing-map
+ * identity: a slug rename, parent-slug change, or re-parent produces a new
+ * map value, so cached hrefs reset exactly when the map changes. Returns no
+ * href for unknown/unpublished ids — callers degrade to plain content
+ * instead of rendering a dead link.
+ */
+export declare function useScreenLink(screenId: string | null | undefined): ResolvedScreenLink;

package/src/lib/app-utils/screen-link-context.js

@@ -0,0 +1,304 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ // Lives in @aglyn/aglyn (not a UI lib) deliberately, WITHOUT a 'use client'
+// banner: every surface that renders canvas nodes already imports this
+// package, and a client boundary here (or importing the shared-ui-jsx
+// barrel from the tenant page) makes the bundler duplicate parts of the
+// module graph — a second canvas/emitter instance renders the site blank.
+import { useContext, useMemo } from "react";
+import { ScreenLinkContext } from "./screen-link-context-value.js";
+import { EXTERNAL_HREF_PATTERN, SAFE_HREF_PATTERN, formatCollectionLinkValue, linkTargetKind, parseCollectionLinkValue, parseEntryLinkValue, parseFeedLinkValue, resolveScreenHref, screenRoutesAnswerFor, splitLinkValue } from "./screen-link-value.js";
+export * from "./screen-link-context-value.js";
+/**
+ * Whether an authored screen id points at nothing (AGL-1893).
+ *
+ * Unpublishing or deleting a screen is a normal authoring action, and until
+ * this existed nothing anywhere reported what it had just broken: a Tabs
+ * link to a retired screen shipped as a live-looking control that silently
+ * did nothing on `aglyn.com/changelog` and `/newsroom` for two days.
+ *
+ * The two "we cannot tell" cases are NOT broken, and the distinction is the
+ * whole safety of this predicate:
+ *
+ * - **no map** — a surface that renders canvas nodes without providing
+ *   `ScreenLinkContext` (an isolated spec, an embed) knows nothing about
+ *   the host's screens, and must not conclude that every link is dead;
+ * - **an empty map** — the same thing one beat earlier: the console's live
+ *   host subscription starts empty, and a moment of `{}` must not repaint a
+ *   whole navigation row as broken and then repaint it back.
+ *
+ * Both failure directions were weighed. Calling a live link broken hides or
+ * disables working navigation on a customer's site; calling a dead link fine
+ * leaves exactly the defect this issue is about. Only the first is
+ * unrecoverable from the visitor's side, so the doubt resolves that way.
+ */ export function isScreenLinkBroken(screens, screenId) {
+    if (!screenId) return false;
+    // Both "we cannot tell" cases, asked of the half of the map that holds this
+    // target's kind: a collection listing (AGL-2799) is judged against the
+    // listings, a screen against the screens — see `screenRoutesAnswerFor`.
+    if (!screenRoutesAnswerFor(screens, screenId)) return false;
+    return resolveScreenHref(screens, screenId) === undefined;
+}
+/**
+ * The extra option a Screen picker needs when its stored value matches none
+ * of the host's screens (AGL-1893).
+ *
+ * The console builds `SCREEN_SELECT` options from the routing map, so a
+ * value the map has lost — the retired `/blog` screen, say — matches
+ * nothing and the field renders EMPTY. Which reads, to the person looking
+ * at it, as "no link set". Meanwhile the element still behaves as linked:
+ * the strip is still a nav landmark, that tab is still skipped as
+ * "navigates", and the panel it would have revealed is still suppressed. So
+ * the one surface where this is repairable was also the one actively
+ * denying there was anything to repair.
+ *
+ * Returns the stored value UNCHANGED as the option's value: naming a dead
+ * target must not rewrite it, or opening the panel and pressing Save would
+ * quietly convert a recoverable reference into something else.
+ *
+ * Three shapes get named, because a Screen picker can legally hold any of
+ * them (AGL-1335 / AGL-1894 / AGL-2799): a screen reference whose screen is
+ * gone, a collection listing whose collection is gone, and a plain address
+ * typed in before the picker existed. The last is not broken — but it is
+ * just as invisible, and an author who cannot see it is the reason those
+ * links are not rename-safe yet.
+ */ export function unavailableScreenLabel(screenId, screensKnown) {
+    // With no map loaded yet nothing is known to be missing, so the id is
+    // shown plainly. Flashing "unavailable" over every link for the beat
+    // before the console's host subscription lands would teach authors to
+    // ignore the warning that matters.
+    if (!screensKnown) return screenId;
+    // A listing has no publish state of its own: its collection is either gone
+    // or no longer has the slug its address is built from. A feed hangs off the
+    // same listing, so it is lost the same two ways (AGL-3118).
+    const collectionId = parseCollectionLinkValue(screenId);
+    if (collectionId) {
+        return `⚠ Unavailable collection listing (${collectionId}) — deleted or has no slug`;
+    }
+    const feedCollectionId = parseFeedLinkValue(screenId);
+    if (feedCollectionId) {
+        return `⚠ Unavailable RSS feed (${feedCollectionId}) — collection deleted or has no slug`;
+    }
+    const entry = parseEntryLinkValue(screenId);
+    return entry ? `⚠ Unavailable entry (${entry.entryId}) — unpublished or deleted` : `⚠ Unavailable screen (${screenId}) — unpublished or deleted`;
+}
+export function unresolvedScreenOption(value, screens) {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (!raw) return undefined;
+    const target = splitLinkValue(raw, undefined);
+    if (target.screenId) {
+        if (resolveScreenHref(screens, target.screenId) !== undefined) {
+            return undefined;
+        }
+        return {
+            value: raw,
+            label: unavailableScreenLabel(target.screenId, screenRoutesAnswerFor(screens, target.screenId))
+        };
+    }
+    return target.href ? {
+        value: raw,
+        label: `⚠ Plain address (${target.href}) — not a screen`
+    } : undefined;
+}
+/**
+ * What a picker calls one routing-map target, or `undefined` for a key the
+ * map does not hold — the label {@link screenLinkTargetOptions} gives it.
+ *
+ * A listing and a feed are labeled with their collection's name and address,
+ * like a screen, and marked as what they are IN the label rather than only by
+ * position: a closed picker shows the chosen label and nothing else, and
+ * "Blog (/blog)" there reads exactly like a screen named Blog. A feed borrows
+ * its collection's name, which is the only name it has (AGL-3119).
+ *
+ * An entry is never named here. A map holds only the entries a page
+ * references, under no label, so an entry is named by the search seam
+ * (`LinkTargetSearchContext`), which reads the entry itself.
+ */ export function screenLinkTargetLabel(key, screens, labels) {
+    var _ref;
+    const href = resolveScreenHref(screens, key);
+    if (href === undefined) return undefined;
+    const collectionId = parseCollectionLinkValue(key);
+    if (collectionId) {
+        var _ref1;
+        return `${(_ref1 = labels == null ? void 0 : labels[key]) != null ? _ref1 : collectionId} (${href}) — collection listing`;
+    }
+    const feedCollectionId = parseFeedLinkValue(key);
+    if (feedCollectionId) {
+        var _ref2, _ref3;
+        const name = (_ref2 = (_ref3 = labels == null ? void 0 : labels[key]) != null ? _ref3 : labels == null ? void 0 : labels[formatCollectionLinkValue(feedCollectionId)]) != null ? _ref2 : feedCollectionId;
+        return `${name} (${href}) — RSS feed`;
+    }
+    if (parseEntryLinkValue(key)) return undefined;
+    return `${(_ref = labels == null ? void 0 : labels[key]) != null ? _ref : key} (${href})`;
+}
+/**
+ * Everything a Screen picker offers, in the order it offers it (AGL-2799):
+ * the host's screens, then its content collections' listing pages, then
+ * their RSS feeds (AGL-3119).
+ *
+ * ONE builder for both pickers — the attributes panel's `SCREEN_SELECT` and
+ * the `Link`-typed prop picker. Each used to map the routing map into options
+ * by itself, so a target added to one list was missing from the other; and
+ * neither offered a collection's listing at all, which is how the drawer on
+ * aglyn.com came to link its blog as a typed `/blog`.
+ *
+ * Entries are left out even when the map holds some: they are searched, not
+ * listed, because a site's entries are far too many to read into a dropdown
+ * — see `LinkTargetSearchContext`.
+ *
+ * `order` keeps each picker's established screen order — by path in the
+ * attributes panel, by name in the prop picker — and the listings and feeds
+ * follow the screens in the same order.
+ */ export function screenLinkTargetOptions(screens, labels, order = 'path') {
+    const pages = [];
+    const listings = [];
+    const feeds = [];
+    for (const [key, path] of Object.entries(screens != null ? screens : {})){
+        var _screenLinkTargetLabel;
+        const kind = linkTargetKind(key);
+        if (kind === 'entry') continue;
+        const label = (_screenLinkTargetLabel = screenLinkTargetLabel(key, screens, labels)) != null ? _screenLinkTargetLabel : key;
+        if (kind === 'collection') {
+            listings.push({
+                value: key,
+                label,
+                kind: 'collection-listing',
+                path
+            });
+        } else if (kind === 'feed') {
+            feeds.push({
+                value: key,
+                label,
+                kind: 'feed',
+                path
+            });
+        } else {
+            pages.push({
+                value: key,
+                label,
+                kind: 'screen',
+                path
+            });
+        }
+    }
+    const compare = (a, b)=>order === 'path' ? a.path.localeCompare(b.path) : a.label.localeCompare(b.label);
+    return [
+        ...pages.sort(compare),
+        ...listings.sort(compare),
+        ...feeds.sort(compare)
+    ].map(({ value, label, kind })=>({
+            value,
+            label,
+            kind
+        }));
+}
+/**
+ * Marks the element in the DOM. Present on the live site too, deliberately:
+ * a smoke pass can then find every dead control on a page with one selector
+ * instead of reading five different components' conditions.
+ */ export const BROKEN_SCREEN_LINK_ATTR = 'data-aglyn-broken-link';
+/** What the AUTHOR is told, on the one surface that can fix it. */ export const BROKEN_SCREEN_LINK_MESSAGE = 'Broken link: this points at a screen or collection listing that is ' + 'unpublished or deleted, so it will not work on the published site. Pick ' + 'a target again in the attributes panel, or clear the link.';
+/**
+ * The editor-only outline. A warning ring rather than an error one: the
+ * screen may be deliberately unpublished and about to come back, and the
+ * page is not broken, one control on it is.
+ */ export const BROKEN_SCREEN_LINK_SX = {
+    outline: '2px dashed',
+    outlineColor: 'warning.main',
+    outlineOffset: '2px',
+    borderRadius: 1
+};
+/**
+ * Props that make a dead screen link visible to its author (AGL-1893).
+ *
+ * The tooltip and the ring are `editorInert` only — that is the static
+ * besigner canvas, the one surface where the person who can fix this is
+ * looking at it. Preview deliberately does NOT get them: preview exists to
+ * show what visitors will see, and an authoring annotation painted into it
+ * is a lie of a different kind.
+ *
+ * The data attribute ships everywhere, canvas and live site alike.
+ */ export function brokenScreenLinkProps(broken, editorInert) {
+    if (!broken) return {};
+    return _extends({
+        [BROKEN_SCREEN_LINK_ATTR]: ''
+    }, editorInert ? {
+        title: BROKEN_SCREEN_LINK_MESSAGE
+    } : null);
+}
+/**
+ * Link VALUE parsing AND resolution live in `./screen-link-value` —
+ * server-safe, because the where-used scan and the Markdown representation of
+ * a page both run on the server, and the `createContext` this module reaches
+ * keeps it out of the `@aglyn/aglyn/server` barrel (AGL-703, AGL-2740).
+ * Re-exported here so every existing importer, and the spec beside this file,
+ * keeps reaching them at the address they have always used.
+ */ export { COLLECTION_LINK_VALUE_PREFIX, ENTRY_LINK_VALUE_PREFIX, EXTERNAL_HREF_PATTERN, FEED_LINK_VALUE_PREFIX, SAFE_HREF_PATTERN, SCREEN_LINK_VALUE_PREFIX, formatCollectionLinkValue, formatEntryLinkValue, formatFeedLinkValue, formatScreenLinkValue, linkTargetKind, nodesReferenceScreen, parseCollectionLinkValue, parseEntryLinkValue, parseFeedLinkValue, parseScreenLinkValue, resolveScreenHref, screenRoutesAnswerFor, splitLinkValue } from "./screen-link-value.js";
+/**
+ * The single href a linking element should render, from the `screenId` +
+ * `href` pair every one of them declares (AGL-1335).
+ *
+ * Button, Screen Link, Link Box and Image each had the same four lines —
+ * resolve the id, safety-check the URL, prefer the id — which is three
+ * copies too many now that a `Link`-typed component prop can feed either
+ * slot with either shape. Hook-shaped because {@link useScreenLink} is;
+ * it is always called, so the hook order never depends on the values.
+ */ export function useLinkTarget(screenId, href) {
+    const target = splitLinkValue(screenId, href);
+    const resolved = useScreenLink(target.screenId);
+    const externalHref = target.href && SAFE_HREF_PATTERN.test(target.href) ? target.href : undefined;
+    const finalHref = target.screenId ? resolved.href : externalHref;
+    return _extends({}, resolved, {
+        href: finalHref,
+        externalHref,
+        leavesSite: Boolean(!target.screenId && externalHref && EXTERNAL_HREF_PATTERN.test(externalHref))
+    });
+}
+/**
+ * Resolves a screen id to its current href. Memoized on the routing-map
+ * identity: a slug rename, parent-slug change, or re-parent produces a new
+ * map value, so cached hrefs reset exactly when the map changes. Returns no
+ * href for unknown/unpublished ids — callers degrade to plain content
+ * instead of rendering a dead link.
+ */ export function useScreenLink(screenId) {
+    const { screens, suppressNavigation, editorInert } = useContext(ScreenLinkContext);
+    const href = useMemo(()=>{
+        if (!screenId) return undefined;
+        const resolved = resolveScreenHref(screens, screenId);
+        if (resolved === undefined) {
+            if (process.env.NODE_ENV !== 'production') {
+                console.warn(`[ScreenLink] screen "${screenId}" has no routing-map entry — ` + 'it may be unpublished or deleted; rendering without an href.');
+            }
+            return undefined;
+        }
+        return resolved;
+    }, [
+        screenId,
+        screens
+    ]);
+    return {
+        href,
+        suppressNavigation: Boolean(suppressNavigation),
+        editorInert: Boolean(editorInert),
+        // NOT `!href`: a suppressed surface has no href for links that resolve
+        // perfectly well, and the whole point of this flag is to separate the
+        // two (AGL-1893).
+        broken: isScreenLinkBroken(screens, screenId)
+    };
+}
+
+//# sourceMappingURL=screen-link-context.js.map

package/src/lib/app-utils/screen-link-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/screen-link-context.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Lives in @aglyn/aglyn (not a UI lib) deliberately, WITHOUT a 'use client'\n// banner: every surface that renders canvas nodes already imports this\n// package, and a client boundary here (or importing the shared-ui-jsx\n// barrel from the tenant page) makes the bundler duplicate parts of the\n// module graph — a second canvas/emitter instance renders the site blank.\nimport { useContext, useMemo } from 'react'\nimport {\n  ScreenLinkContext,\n  type ScreenRouteMap,\n} from './screen-link-context-value'\nimport {\n  EXTERNAL_HREF_PATTERN,\n  SAFE_HREF_PATTERN,\n  formatCollectionLinkValue,\n  linkTargetKind,\n  parseCollectionLinkValue,\n  parseEntryLinkValue,\n  parseFeedLinkValue,\n  resolveScreenHref,\n  screenRoutesAnswerFor,\n  splitLinkValue,\n} from './screen-link-value'\n\nexport * from './screen-link-context-value'\n\nexport interface ResolvedScreenLink {\n  /** Site-relative href (`/`, `/company/about`), undefined when unresolvable. */\n  href?: string\n  suppressNavigation: boolean\n  /** True only on the static besigner canvas — interactions are inert. */\n  editorInert: boolean\n  /**\n   * A screen id WAS authored and the routing map does not have it — the\n   * target is unpublished or deleted (AGL-1893).\n   *\n   * Distinct from \"no href\": the canvas and the preview withhold hrefs on\n   * purpose, and an element with no link at all never had one to lose.\n   * Only this flag means the author asked for a link that cannot exist, and\n   * only elements reading THIS may say so — see {@link isScreenLinkBroken}\n   * for why an absent or empty map is deliberately not \"broken\".\n   */\n  broken: boolean\n}\n\n/**\n * Whether an authored screen id points at nothing (AGL-1893).\n *\n * Unpublishing or deleting a screen is a normal authoring action, and until\n * this existed nothing anywhere reported what it had just broken: a Tabs\n * link to a retired screen shipped as a live-looking control that silently\n * did nothing on `aglyn.com/changelog` and `/newsroom` for two days.\n *\n * The two \"we cannot tell\" cases are NOT broken, and the distinction is the\n * whole safety of this predicate:\n *\n * - **no map** — a surface that renders canvas nodes without providing\n *   `ScreenLinkContext` (an isolated spec, an embed) knows nothing about\n *   the host's screens, and must not conclude that every link is dead;\n * - **an empty map** — the same thing one beat earlier: the console's live\n *   host subscription starts empty, and a moment of `{}` must not repaint a\n *   whole navigation row as broken and then repaint it back.\n *\n * Both failure directions were weighed. Calling a live link broken hides or\n * disables working navigation on a customer's site; calling a dead link fine\n * leaves exactly the defect this issue is about. Only the first is\n * unrecoverable from the visitor's side, so the doubt resolves that way.\n */\nexport function isScreenLinkBroken(\n  screens: ScreenRouteMap | undefined,\n  screenId: string | null | undefined,\n): boolean {\n  if (!screenId) return false\n  // Both \"we cannot tell\" cases, asked of the half of the map that holds this\n  // target's kind: a collection listing (AGL-2799) is judged against the\n  // listings, a screen against the screens — see `screenRoutesAnswerFor`.\n  if (!screenRoutesAnswerFor(screens, screenId)) return false\n  return resolveScreenHref(screens, screenId) === undefined\n}\n\n/**\n * The extra option a Screen picker needs when its stored value matches none\n * of the host's screens (AGL-1893).\n *\n * The console builds `SCREEN_SELECT` options from the routing map, so a\n * value the map has lost — the retired `/blog` screen, say — matches\n * nothing and the field renders EMPTY. Which reads, to the person looking\n * at it, as \"no link set\". Meanwhile the element still behaves as linked:\n * the strip is still a nav landmark, that tab is still skipped as\n * \"navigates\", and the panel it would have revealed is still suppressed. So\n * the one surface where this is repairable was also the one actively\n * denying there was anything to repair.\n *\n * Returns the stored value UNCHANGED as the option's value: naming a dead\n * target must not rewrite it, or opening the panel and pressing Save would\n * quietly convert a recoverable reference into something else.\n *\n * Three shapes get named, because a Screen picker can legally hold any of\n * them (AGL-1335 / AGL-1894 / AGL-2799): a screen reference whose screen is\n * gone, a collection listing whose collection is gone, and a plain address\n * typed in before the picker existed. The last is not broken — but it is\n * just as invisible, and an author who cannot see it is the reason those\n * links are not rename-safe yet.\n */\nexport function unavailableScreenLabel(\n  screenId: string,\n  screensKnown: boolean,\n): string {\n  // With no map loaded yet nothing is known to be missing, so the id is\n  // shown plainly. Flashing \"unavailable\" over every link for the beat\n  // before the console's host subscription lands would teach authors to\n  // ignore the warning that matters.\n  if (!screensKnown) return screenId\n  // A listing has no publish state of its own: its collection is either gone\n  // or no longer has the slug its address is built from. A feed hangs off the\n  // same listing, so it is lost the same two ways (AGL-3118).\n  const collectionId = parseCollectionLinkValue(screenId)\n  if (collectionId) {\n    return `⚠ Unavailable collection listing (${collectionId}) — deleted or has no slug`\n  }\n  const feedCollectionId = parseFeedLinkValue(screenId)\n  if (feedCollectionId) {\n    return `⚠ Unavailable RSS feed (${feedCollectionId}) — collection deleted or has no slug`\n  }\n  const entry = parseEntryLinkValue(screenId)\n  return entry\n    ? `⚠ Unavailable entry (${entry.entryId}) — unpublished or deleted`\n    : `⚠ Unavailable screen (${screenId}) — unpublished or deleted`\n}\n\nexport function unresolvedScreenOption(\n  value: unknown,\n  screens: ScreenRouteMap | undefined,\n): { value: string; label: string } | undefined {\n  const raw = typeof value === 'string' ? value.trim() : ''\n  if (!raw) return undefined\n  const target = splitLinkValue(raw, undefined)\n  if (target.screenId) {\n    if (resolveScreenHref(screens, target.screenId) !== undefined) {\n      return undefined\n    }\n    return {\n      value: raw,\n      label: unavailableScreenLabel(\n        target.screenId,\n        screenRoutesAnswerFor(screens, target.screenId),\n      ),\n    }\n  }\n  return target.href\n    ? { value: raw, label: `⚠ Plain address (${target.href}) — not a screen` }\n    : undefined\n}\n\n/** One target a link picker offers — see {@link screenLinkTargetOptions}. */\nexport interface ScreenLinkTargetOption {\n  /**\n   * The routing-map key: a bare screen id, a collection listing's\n   * `collection:<id>`, or its feed's `feed:<id>`. Stored as it is in a screen\n   * slot, and through `formatScreenLinkValue` in a `Link`-typed prop.\n   */\n  value: string\n  label: string\n  kind: 'screen' | 'collection-listing' | 'feed'\n}\n\n/**\n * What a picker calls one routing-map target, or `undefined` for a key the\n * map does not hold — the label {@link screenLinkTargetOptions} gives it.\n *\n * A listing and a feed are labeled with their collection's name and address,\n * like a screen, and marked as what they are IN the label rather than only by\n * position: a closed picker shows the chosen label and nothing else, and\n * \"Blog (/blog)\" there reads exactly like a screen named Blog. A feed borrows\n * its collection's name, which is the only name it has (AGL-3119).\n *\n * An entry is never named here. A map holds only the entries a page\n * references, under no label, so an entry is named by the search seam\n * (`LinkTargetSearchContext`), which reads the entry itself.\n */\nexport function screenLinkTargetLabel(\n  key: string,\n  screens: ScreenRouteMap | undefined,\n  labels: Record<string, string> | undefined,\n): string | undefined {\n  const href = resolveScreenHref(screens, key)\n  if (href === undefined) return undefined\n  const collectionId = parseCollectionLinkValue(key)\n  if (collectionId) {\n    return `${labels?.[key] ?? collectionId} (${href}) — collection listing`\n  }\n  const feedCollectionId = parseFeedLinkValue(key)\n  if (feedCollectionId) {\n    const name =\n      labels?.[key] ??\n      labels?.[formatCollectionLinkValue(feedCollectionId)] ??\n      feedCollectionId\n    return `${name} (${href}) — RSS feed`\n  }\n  if (parseEntryLinkValue(key)) return undefined\n  return `${labels?.[key] ?? key} (${href})`\n}\n\n/**\n * Everything a Screen picker offers, in the order it offers it (AGL-2799):\n * the host's screens, then its content collections' listing pages, then\n * their RSS feeds (AGL-3119).\n *\n * ONE builder for both pickers — the attributes panel's `SCREEN_SELECT` and\n * the `Link`-typed prop picker. Each used to map the routing map into options\n * by itself, so a target added to one list was missing from the other; and\n * neither offered a collection's listing at all, which is how the drawer on\n * aglyn.com came to link its blog as a typed `/blog`.\n *\n * Entries are left out even when the map holds some: they are searched, not\n * listed, because a site's entries are far too many to read into a dropdown\n * — see `LinkTargetSearchContext`.\n *\n * `order` keeps each picker's established screen order — by path in the\n * attributes panel, by name in the prop picker — and the listings and feeds\n * follow the screens in the same order.\n */\nexport function screenLinkTargetOptions(\n  screens: ScreenRouteMap | undefined,\n  labels: Record<string, string> | undefined,\n  order: 'path' | 'label' = 'path',\n): ScreenLinkTargetOption[] {\n  type Ranked = ScreenLinkTargetOption & { path: string }\n  const pages: Ranked[] = []\n  const listings: Ranked[] = []\n  const feeds: Ranked[] = []\n  for (const [key, path] of Object.entries(screens ?? {})) {\n    const kind = linkTargetKind(key)\n    if (kind === 'entry') continue\n    const label = screenLinkTargetLabel(key, screens, labels) ?? key\n    if (kind === 'collection') {\n      listings.push({ value: key, label, kind: 'collection-listing', path })\n    } else if (kind === 'feed') {\n      feeds.push({ value: key, label, kind: 'feed', path })\n    } else {\n      pages.push({ value: key, label, kind: 'screen', path })\n    }\n  }\n  const compare = (a: Ranked, b: Ranked) =>\n    order === 'path'\n      ? a.path.localeCompare(b.path)\n      : a.label.localeCompare(b.label)\n  return [\n    ...pages.sort(compare),\n    ...listings.sort(compare),\n    ...feeds.sort(compare),\n  ].map(({ value, label, kind }) => ({ value, label, kind }))\n}\n\n/**\n * Marks the element in the DOM. Present on the live site too, deliberately:\n * a smoke pass can then find every dead control on a page with one selector\n * instead of reading five different components' conditions.\n */\nexport const BROKEN_SCREEN_LINK_ATTR = 'data-aglyn-broken-link'\n\n/** What the AUTHOR is told, on the one surface that can fix it. */\nexport const BROKEN_SCREEN_LINK_MESSAGE =\n  'Broken link: this points at a screen or collection listing that is ' +\n  'unpublished or deleted, so it will not work on the published site. Pick ' +\n  'a target again in the attributes panel, or clear the link.'\n\n/**\n * The editor-only outline. A warning ring rather than an error one: the\n * screen may be deliberately unpublished and about to come back, and the\n * page is not broken, one control on it is.\n */\nexport const BROKEN_SCREEN_LINK_SX = {\n  outline: '2px dashed',\n  outlineColor: 'warning.main',\n  outlineOffset: '2px',\n  borderRadius: 1,\n}\n\n/**\n * Props that make a dead screen link visible to its author (AGL-1893).\n *\n * The tooltip and the ring are `editorInert` only — that is the static\n * besigner canvas, the one surface where the person who can fix this is\n * looking at it. Preview deliberately does NOT get them: preview exists to\n * show what visitors will see, and an authoring annotation painted into it\n * is a lie of a different kind.\n *\n * The data attribute ships everywhere, canvas and live site alike.\n */\nexport function brokenScreenLinkProps(\n  broken: boolean,\n  editorInert: boolean,\n): Record<string, unknown> {\n  if (!broken) return {}\n  return {\n    [BROKEN_SCREEN_LINK_ATTR]: '',\n    ...(editorInert ? { title: BROKEN_SCREEN_LINK_MESSAGE } : null),\n  }\n}\n\n/**\n * Link VALUE parsing AND resolution live in `./screen-link-value` —\n * server-safe, because the where-used scan and the Markdown representation of\n * a page both run on the server, and the `createContext` this module reaches\n * keeps it out of the `@aglyn/aglyn/server` barrel (AGL-703, AGL-2740).\n * Re-exported here so every existing importer, and the spec beside this file,\n * keeps reaching them at the address they have always used.\n */\nexport {\n  COLLECTION_LINK_VALUE_PREFIX,\n  ENTRY_LINK_VALUE_PREFIX,\n  EXTERNAL_HREF_PATTERN,\n  FEED_LINK_VALUE_PREFIX,\n  SAFE_HREF_PATTERN,\n  SCREEN_LINK_VALUE_PREFIX,\n  formatCollectionLinkValue,\n  formatEntryLinkValue,\n  formatFeedLinkValue,\n  formatScreenLinkValue,\n  linkTargetKind,\n  nodesReferenceScreen,\n  parseCollectionLinkValue,\n  parseEntryLinkValue,\n  parseFeedLinkValue,\n  parseScreenLinkValue,\n  resolveScreenHref,\n  screenRoutesAnswerFor,\n  splitLinkValue,\n  type LinkTargetKind,\n} from './screen-link-value'\n\n/** What a linking element renders — see {@link useLinkTarget}. */\nexport interface ResolvedLinkTarget extends ResolvedScreenLink {\n  /** The literal href in play once safety-checked, when no screen resolved. */\n  externalHref?: string\n  /** True when `href` leaves the site — what \"open in a new tab\" may act on. */\n  leavesSite: boolean\n}\n\n/**\n * The single href a linking element should render, from the `screenId` +\n * `href` pair every one of them declares (AGL-1335).\n *\n * Button, Screen Link, Link Box and Image each had the same four lines —\n * resolve the id, safety-check the URL, prefer the id — which is three\n * copies too many now that a `Link`-typed component prop can feed either\n * slot with either shape. Hook-shaped because {@link useScreenLink} is;\n * it is always called, so the hook order never depends on the values.\n */\nexport function useLinkTarget(\n  screenId: string | null | undefined,\n  href: string | null | undefined,\n): ResolvedLinkTarget {\n  const target = splitLinkValue(screenId, href)\n  const resolved = useScreenLink(target.screenId)\n  const externalHref =\n    target.href && SAFE_HREF_PATTERN.test(target.href) ? target.href : undefined\n  const finalHref = target.screenId ? resolved.href : externalHref\n  return {\n    ...resolved,\n    href: finalHref,\n    externalHref,\n    leavesSite: Boolean(\n      !target.screenId && externalHref && EXTERNAL_HREF_PATTERN.test(externalHref),\n    ),\n  }\n}\n\n/**\n * Resolves a screen id to its current href. Memoized on the routing-map\n * identity: a slug rename, parent-slug change, or re-parent produces a new\n * map value, so cached hrefs reset exactly when the map changes. Returns no\n * href for unknown/unpublished ids — callers degrade to plain content\n * instead of rendering a dead link.\n */\nexport function useScreenLink(\n  screenId: string | null | undefined,\n): ResolvedScreenLink {\n  const { screens, suppressNavigation, editorInert } = useContext(ScreenLinkContext)\n  const href = useMemo(() => {\n    if (!screenId) return undefined\n    const resolved = resolveScreenHref(screens, screenId)\n    if (resolved === undefined) {\n      if (process.env.NODE_ENV !== 'production') {\n        console.warn(\n          `[ScreenLink] screen \"${screenId}\" has no routing-map entry — ` +\n            'it may be unpublished or deleted; rendering without an href.',\n        )\n      }\n      return undefined\n    }\n    return resolved\n  }, [screenId, screens])\n  return {\n    href,\n    suppressNavigation: Boolean(suppressNavigation),\n    editorInert: Boolean(editorInert),\n    // NOT `!href`: a suppressed surface has no href for links that resolve\n    // perfectly well, and the whole point of this flag is to separate the\n    // two (AGL-1893).\n    broken: isScreenLinkBroken(screens, screenId),\n  }\n}\n"],"names":["useContext","useMemo","ScreenLinkContext","EXTERNAL_HREF_PATTERN","SAFE_HREF_PATTERN","formatCollectionLinkValue","linkTargetKind","parseCollectionLinkValue","parseEntryLinkValue","parseFeedLinkValue","resolveScreenHref","screenRoutesAnswerFor","splitLinkValue","isScreenLinkBroken","screens","screenId","undefined","unavailableScreenLabel","screensKnown","collectionId","feedCollectionId","entry","entryId","unresolvedScreenOption","value","raw","trim","target","label","href","screenLinkTargetLabel","key","labels","name","screenLinkTargetOptions","order","pages","listings","feeds","path","Object","entries","kind","push","compare","a","b","localeCompare","sort","map","BROKEN_SCREEN_LINK_ATTR","BROKEN_SCREEN_LINK_MESSAGE","BROKEN_SCREEN_LINK_SX","outline","outlineColor","outlineOffset","borderRadius","brokenScreenLinkProps","broken","editorInert","title","COLLECTION_LINK_VALUE_PREFIX","ENTRY_LINK_VALUE_PREFIX","FEED_LINK_VALUE_PREFIX","SCREEN_LINK_VALUE_PREFIX","formatEntryLinkValue","formatFeedLinkValue","formatScreenLinkValue","nodesReferenceScreen","parseScreenLinkValue","useLinkTarget","resolved","useScreenLink","externalHref","test","finalHref","leavesSite","Boolean","suppressNavigation","process","env","NODE_ENV","console","warn"],"mappings":"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"}