@aglyn/aglyn 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aglyn/aglyn",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "license": "Apache-2.0",
   "homepage": "https://aglyn.com",
   "repository": {
@@ -37,16 +37,16 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@aglyn/shared-data-enums": "1.0.0",
-    "@aglyn/shared-data-mdi": "1.0.0",
-    "@aglyn/shared-data-types": "1.0.0",
-    "@aglyn/shared-util-email": "1.0.0",
-    "@aglyn/shared-util-first-touch": "1.0.0",
-    "@aglyn/shared-util-http": "1.0.0",
-    "@aglyn/shared-util-logger": "1.0.0",
-    "@aglyn/shared-util-timestamp": "1.0.0",
-    "@aglyn/shared-util-tools": "1.0.0",
-    "@aglyn/shared-util-vendor": "1.0.0",
+    "@aglyn/shared-data-enums": "1.1.0",
+    "@aglyn/shared-data-mdi": "1.1.0",
+    "@aglyn/shared-data-types": "1.1.0",
+    "@aglyn/shared-util-email": "1.1.0",
+    "@aglyn/shared-util-first-touch": "1.1.0",
+    "@aglyn/shared-util-http": "1.1.0",
+    "@aglyn/shared-util-logger": "1.1.0",
+    "@aglyn/shared-util-timestamp": "1.1.0",
+    "@aglyn/shared-util-tools": "1.1.0",
+    "@aglyn/shared-util-vendor": "1.1.0",
     "@data-driven-forms/react-form-renderer": "^4.2.0",
     "@msgpack/msgpack": "^3.1.3",
     "@types/unist": "^3.0.3",

package/src/lib/app-utils/compose-reusable-components.d.ts

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 import type { AglynNodeSchema, NodeId, ReusableComponentIcon, ReusableComponentProp } from '../foundation';
+import { type HostTokenSource } from './host-tokens';
 export * from './reusable-component-keys';
 export * from './reusable-prop-values';
 /**
@@ -413,6 +414,17 @@ formatted?: Readonly<Record<string, unknown>> | null): NormalizedNodes<N>;
  * what keeps the component editor showing the parts a page will hide.
  */
 export declare function isNodeHiddenByDirective(props: unknown): boolean;
+/**
+ * Whether the site's own values hide this node (AGL-4119): `hideIf` or
+ * `hideUnless` bound to a `{{host.*}}` token, read against `host`. A header
+ * shows the logo when the site has one and the name when it does not, and
+ * each carries the directive that says so.
+ *
+ * Only a directive naming a host token is read. A directive with a literal
+ * value on an ordinary page's own node stays as inert as it has always been
+ * ({@link isNodeHiddenByDirective} says why it is the graft that reads those).
+ */
+export declare function isNodeHiddenByHost(props: unknown, host: HostTokenSource | null | undefined): boolean;
 /**
  * Drops every node under `rootId` whose props ask to be hidden, along with
  * its whole subtree and its entry in its parent's child list, and strips
@@ -433,6 +445,16 @@ export declare function isNodeHiddenByDirective(props: unknown): boolean;
  * overwhelmingly common case costs one scan and allocates nothing.
  */
 export declare function pruneHiddenNodes<N extends AglynNodeSchema = AglynNodeSchema>(nodes: NormalizedNodes<N>, rootId: NodeId): NormalizedNodes<N>;
+/**
+ * {@link pruneHiddenNodes} for the directives bound to a `{{host.*}}` token
+ * (AGL-4119), once the site is known: over the composed tree, ahead of the
+ * host tokens themselves, by every surface that fills those in. What a page
+ * hides for itself has been pruned by then.
+ *
+ * Returns the input unchanged when no node names one, which is every page of
+ * a site whose layout does not.
+ */
+export declare function pruneHostHiddenNodes<N extends AglynNodeSchema = AglynNodeSchema>(nodes: NormalizedNodes<N>, host: HostTokenSource | null | undefined, rootId?: NodeId): NormalizedNodes<N>;
 /**
  * Expands reusable-component instance nodes (componentId
  * {@link REUSABLE_INSTANCE_COMPONENT_ID}, `props.refId` → definition id) by

package/src/lib/app-utils/compose-reusable-components.js

@@ -17,10 +17,12 @@ import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_wi
  * limitations under the License.
  */ // By path: the naming rule alone, without the icon catalog's loader beside it.
 import { iconPathPropName } from "@aglyn/shared-data-mdi/utils/icon-path-prop-name";
+import { CANVAS_ROOT_ELEMENT_ID } from "../foundation/constants/canvas.js";
 import { reusablePropValueClass } from "../foundation/definitions/property-kinds.js";
 import { COMPONENT_NODE_ID_PREFIX, COMPONENT_PROP_TOKEN_PREFIX, INSTANCE_CARRIED_NODE_FIELDS, INSTANCE_CARRIED_PROPS, NODE_HIDE_IF_PROP, NODE_HIDE_UNLESS_PROP, REUSABLE_INSTANCE_COMPONENT_ID, REUSABLE_INSTANCE_PROP_HTML_KEY, REUSABLE_INSTANCE_PROP_VALUES_KEY, STYLE_OVERRIDES_ROOT_KEY } from "./reusable-component-keys.js";
 import { REPEAT_DIRECTIVE_PROPS, REPEAT_SELF_PROP, repeatKey, withoutRepeatDirective } from "./expand-repeatables.js";
 import { FORM_COMPONENT_ID, FORM_ID_PROP } from "./forms.js";
+import { hostTokensIn, resolveHostTokens } from "./host-tokens.js";
 /** The Form's after-submit reveal target: a node id (`form.tsx`). */ const FORM_REVEAL_NODE_PROP = 'revealNodeId';
 import { mergeNodeSx } from "./merge-node-sx.js";
 import { hasUrlScheme, isSafeNodeUrl, NODE_URL_PROPS } from "./node-url-policy.js";
@@ -823,48 +825,62 @@ function hasVisibilityDirective(props) {
     const bag = props;
     return NODE_HIDE_IF_PROP in bag || NODE_HIDE_UNLESS_PROP in bag;
 }
+/** A directive bound to the site's own values, like `{{host.logo}}`. */ function namesHostToken(value) {
+    return typeof value === 'string' && hostTokensIn(value).length > 0;
+}
+/**
+ * Whether the site's own values hide this node (AGL-4119): `hideIf` or
+ * `hideUnless` bound to a `{{host.*}}` token, read against `host`. A header
+ * shows the logo when the site has one and the name when it does not, and
+ * each carries the directive that says so.
+ *
+ * Only a directive naming a host token is read. A directive with a literal
+ * value on an ordinary page's own node stays as inert as it has always been
+ * ({@link isNodeHiddenByDirective} says why it is the graft that reads those).
+ */ export function isNodeHiddenByHost(props, host) {
+    if (!props || typeof props !== 'object' || Array.isArray(props)) return false;
+    const bag = props;
+    const hideIf = bag[NODE_HIDE_IF_PROP];
+    const hideUnless = bag[NODE_HIDE_UNLESS_PROP];
+    if (namesHostToken(hideIf) && readYesNoValue(resolveHostTokens(String(hideIf), host)) === true) {
+        return true;
+    }
+    return namesHostToken(hideUnless) && readYesNoValue(resolveHostTokens(String(hideUnless), host)) === false;
+}
 /**
  * The node minus its visibility directives — they are compose-time
  * instructions, and `Leaf` spreads whatever survives onto the component,
  * so leaving them would put `hideif="…"` on the DOM of every node that
  * declared one and stayed.
+ *
+ * One bound to a `{{host.*}}` token stays: the site's values fill in later,
+ * and {@link pruneHostHiddenNodes} reads it then.
  */ function withoutVisibilityDirectives(node) {
     if (!hasVisibilityDirective(node == null ? void 0 : node.props)) return node;
     const props = _extends({}, node.props);
-    delete props[NODE_HIDE_IF_PROP];
-    delete props[NODE_HIDE_UNLESS_PROP];
+    if (!namesHostToken(props[NODE_HIDE_IF_PROP])) delete props[NODE_HIDE_IF_PROP];
+    if (!namesHostToken(props[NODE_HIDE_UNLESS_PROP])) delete props[NODE_HIDE_UNLESS_PROP];
     return _extends({}, node, {
         props: props
     });
 }
-/**
- * Drops every node under `rootId` whose props ask to be hidden, along with
- * its whole subtree and its entry in its parent's child list, and strips
- * the directives off everything that survives (AGL-1314).
- *
- * Structural rather than a `display: none`: an instance can already hide a
- * leaf with a per-leaf style override (AGL-1332), but that still ships the
- * markup, still fetches the image, still leaves the grid column, and still
- * leaves the control in the tab order. "This page has no mockup" is a
- * statement about the tree, so it is made in the tree.
- *
- * `rootId` itself is never dropped. The graft below wires the instance
- * node's single child to the definition root by id, so a self-hiding root
- * would leave a dangling reference; a component that should not appear at
- * all is a decision for the page that placed it, not for the definition.
- *
- * Returns the input unchanged when no node carries a directive, so the
- * overwhelmingly common case costs one scan and allocates nothing.
- */ export function pruneHiddenNodes(nodes, rootId) {
-    if (!nodes) return nodes;
-    let sawDirective = false;
-    for (const node of Object.values(nodes)){
-        if (hasVisibilityDirective(node == null ? void 0 : node.props)) {
-            sawDirective = true;
-            break;
-        }
+/** The node minus the directives bound to a `{{host.*}}` token, now they have been read. */ function withoutHostDirectives(node) {
+    const bag = node == null ? void 0 : node.props;
+    if (!bag || !(namesHostToken(bag[NODE_HIDE_IF_PROP]) || namesHostToken(bag[NODE_HIDE_UNLESS_PROP]))) {
+        return node;
     }
-    if (!sawDirective) return nodes;
+    const props = _extends({}, bag);
+    if (namesHostToken(props[NODE_HIDE_IF_PROP])) delete props[NODE_HIDE_IF_PROP];
+    if (namesHostToken(props[NODE_HIDE_UNLESS_PROP])) delete props[NODE_HIDE_UNLESS_PROP];
+    return _extends({}, node, {
+        props: props
+    });
+}
+/**
+ * Drops every node under `rootId` that `isHidden` answers for, along with its
+ * subtree and its entry in its parent's child list, and hands every survivor
+ * to `keep`. The walk both prunes below share.
+ */ function pruneNodes(nodes, rootId, isHidden, keep) {
     const hidden = new Set();
     const seen = new Set();
     const walk = (id)=>{
@@ -875,9 +891,8 @@ function hasVisibilityDirective(props) {
         seen.add(id);
         const children = Array.isArray(node.nodes) ? node.nodes : [];
         for (const childId of children){
-            var _nodes_childId;
             if (typeof childId !== 'string' || !nodes[childId]) continue;
-            if (isNodeHiddenByDirective((_nodes_childId = nodes[childId]) == null ? void 0 : _nodes_childId.props)) {
+            if (isHidden(nodes[childId])) {
                 hidden.add(childId);
                 for (const descendant of collectDescendantIds(nodes, childId)){
                     hidden.add(descendant);
@@ -891,7 +906,7 @@ function hasVisibilityDirective(props) {
     const next = {};
     for (const [id, node] of Object.entries(nodes)){
         if (hidden.has(id)) continue;
-        const kept = withoutVisibilityDirectives(node);
+        const kept = keep(node);
         const children = Array.isArray(kept == null ? void 0 : kept.nodes) ? kept.nodes : null;
         const survivors = children && children.some((childId)=>hidden.has(childId)) ? children.filter((childId)=>!hidden.has(childId)) : null;
         next[id] = survivors ? _extends({}, kept, {
@@ -900,6 +915,53 @@ function hasVisibilityDirective(props) {
     }
     return next;
 }
+/**
+ * Drops every node under `rootId` whose props ask to be hidden, along with
+ * its whole subtree and its entry in its parent's child list, and strips
+ * the directives off everything that survives (AGL-1314).
+ *
+ * Structural rather than a `display: none`: an instance can already hide a
+ * leaf with a per-leaf style override (AGL-1332), but that still ships the
+ * markup, still fetches the image, still leaves the grid column, and still
+ * leaves the control in the tab order. "This page has no mockup" is a
+ * statement about the tree, so it is made in the tree.
+ *
+ * `rootId` itself is never dropped. The graft below wires the instance
+ * node's single child to the definition root by id, so a self-hiding root
+ * would leave a dangling reference; a component that should not appear at
+ * all is a decision for the page that placed it, not for the definition.
+ *
+ * Returns the input unchanged when no node carries a directive, so the
+ * overwhelmingly common case costs one scan and allocates nothing.
+ */ export function pruneHiddenNodes(nodes, rootId) {
+    if (!nodes) return nodes;
+    let sawDirective = false;
+    for (const node of Object.values(nodes)){
+        if (hasVisibilityDirective(node == null ? void 0 : node.props)) {
+            sawDirective = true;
+            break;
+        }
+    }
+    if (!sawDirective) return nodes;
+    return pruneNodes(nodes, rootId, (node)=>isNodeHiddenByDirective(node == null ? void 0 : node.props), withoutVisibilityDirectives);
+}
+/**
+ * {@link pruneHiddenNodes} for the directives bound to a `{{host.*}}` token
+ * (AGL-4119), once the site is known: over the composed tree, ahead of the
+ * host tokens themselves, by every surface that fills those in. What a page
+ * hides for itself has been pruned by then.
+ *
+ * Returns the input unchanged when no node names one, which is every page of
+ * a site whose layout does not.
+ */ export function pruneHostHiddenNodes(nodes, host, rootId = CANVAS_ROOT_ELEMENT_ID) {
+    if (!nodes) return nodes;
+    const named = Object.values(nodes).some((node)=>{
+        const bag = node == null ? void 0 : node.props;
+        return Boolean(bag && (namesHostToken(bag[NODE_HIDE_IF_PROP]) || namesHostToken(bag[NODE_HIDE_UNLESS_PROP])));
+    });
+    if (!named) return nodes;
+    return pruneNodes(nodes, rootId, (node)=>isNodeHiddenByHost(node == null ? void 0 : node.props, host), withoutHostDirectives);
+}
 /**
  * Expands reusable-component instance nodes (componentId
  * {@link REUSABLE_INSTANCE_COMPONENT_ID}, `props.refId` → definition id) by