@elastic/isomer-sdk 0.0.0 → 0.2.0

package/dist/pack/primitive_pack.js

@@ -0,0 +1,92 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+// A primitive pack as a value: a vocabulary, and the optional surfaces every
+// primitive in it implements. Additive: a runtime composes any number of packs,
+// and nothing about a pack decides how a composition is framed.
+import { IsomerError } from '../composition/error.js';
+/**
+ * Builds a {@link PrimitivePack}.
+ *
+ * `TTheme` is the palette a frame must supply for this pack's nodes to be drawn
+ * on the `snapshot` surface: `definePrimitivePack<CoreTokens>(input)`. Omitted, it is
+ * `unknown`, which requires nothing.
+ */
+export const definePrimitivePack = (input) => {
+    if (input.primitives.length === 0) {
+        throw new IsomerError('EMPTY_PACK', `primitive pack "${input.id}": at least one primitive is required`);
+    }
+    assertUniquePrimitiveTypes(input.id, input.primitives);
+    assertUniqueEnhancementIds(input.id, input.enhancements ?? []);
+    const types = new Set(input.primitives.map((definition) => definition.type));
+    assertGroupedOnce(input.id, input.authoring?.groups ?? [], types);
+    for (const type of input.slackAssetTypes ?? []) {
+        if (!types.has(type)) {
+            throw new IsomerError('UNKNOWN_PRIMITIVE_TYPE', `primitive pack "${input.id}": slackAssetTypes names primitive type "${type}", which the pack does not register`);
+        }
+    }
+    const styleCollector = input.styleCollector ?? input.styleAdapter?.styleCollector;
+    return {
+        id: input.id,
+        surfaces: input.surfaces ?? [],
+        primitives: input.primitives,
+        types,
+        icons: iconsByType(input.primitives),
+        enhancements: input.enhancements ?? [],
+        slackAssetTypes: new Set(input.slackAssetTypes ?? []),
+        ...(input.styleAdapter !== undefined
+            ? { styleAdapter: input.styleAdapter }
+            : {}),
+        ...(styleCollector !== undefined ? { styleCollector } : {}),
+        ...(input.authoring !== undefined ? { authoring: input.authoring } : {}),
+    };
+};
+/** Each definition's `icon` by type, null-prototype so a type such as `__proto__` is an ordinary key. */
+export const iconsByType = (primitives) => {
+    const icons = Object.create(null);
+    for (const { type, icon } of primitives) {
+        if (icon !== undefined) {
+            icons[type] = icon;
+        }
+    }
+    return Object.freeze(icons);
+};
+/** Throws if `primitives` repeats a type. */
+const assertUniquePrimitiveTypes = (id, primitives) => {
+    const seen = new Set();
+    for (const { type } of primitives) {
+        if (seen.has(type)) {
+            throw new IsomerError('DUPLICATE_PRIMITIVE_TYPE', `primitive pack "${id}": primitive type "${type}" registered twice`);
+        }
+        seen.add(type);
+    }
+};
+/** Throws if a group names a type outside `types`, or two groups share a type. */
+const assertGroupedOnce = (id, groups, types) => {
+    const grouped = new Set();
+    for (const { title, types: members } of groups) {
+        for (const type of members) {
+            if (!types.has(type)) {
+                throw new IsomerError('UNKNOWN_PRIMITIVE_TYPE', `primitive pack "${id}": group "${title}" names primitive type "${type}", which the pack does not register`);
+            }
+            if (grouped.has(type)) {
+                throw new IsomerError('DUPLICATE_PRIMITIVE_TYPE', `primitive pack "${id}": primitive type "${type}" is in two groups`);
+            }
+            grouped.add(type);
+        }
+    }
+};
+/** Throws if this pack registers the same enhancement id twice. */
+const assertUniqueEnhancementIds = (id, enhancements) => {
+    const seen = new Set();
+    for (const definition of enhancements) {
+        if (seen.has(definition.id)) {
+            throw new IsomerError('DUPLICATE_ENHANCEMENT', `primitive pack "${id}": enhancement "${definition.id}" registered twice`);
+        }
+        seen.add(definition.id);
+    }
+};
+//# sourceMappingURL=primitive_pack.js.map

package/dist/pack/primitive_pack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive_pack.js","sourceRoot":"","sources":["../../src/pack/primitive_pack.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one\n * or more contributor license agreements. Licensed under the Elastic License\n * 2.0; you may not use this file except in compliance with the Elastic License\n * 2.0.\n */\n\n// A primitive pack as a value: a vocabulary, and the optional surfaces every\n// primitive in it implements. Additive: a runtime composes any number of packs,\n// and nothing about a pack decides how a composition is framed.\n\nimport { IsomerError } from '../composition/error';\nimport type { PrimitiveIcon } from '../define/primitive_icon';\nimport type {\n  AnyPrimitiveDefinition,\n  OptionalSurface,\n  StyleHandle,\n} from '../define/primitive_module';\n\nimport type { EnhancementDefinition } from './enhancements';\n\n/**\n * The authoring-schema material a pack contributes for its own primitives.\n *\n * A subset of `AuthoringJsonSchemaOptions`: `$id`, `title`, `description`, and\n * `composition` describe the whole authoring schema a runtime builds, which is\n * a host decision, not a pack one. `pack/` does not import `validate/` for\n * this, so the shape is declared here rather than reused by reference.\n */\nexport interface PackAuthoringOptions {\n  /** `$def` id to `description`, for this pack's own primitives. */\n  describe?: Readonly<Record<string, string>>;\n  /** `$defId.property` paths to drop, from this pack's own primitives. */\n  omitProperties?: readonly string[];\n  /** Headings an index catalog sorts this pack's primitives under, in order. */\n  groups?: readonly PrimitiveGroup[];\n}\n\n/** A titled set of primitive types, listed together in an index catalog. */\nexport interface PrimitiveGroup {\n  title: string;\n  types: readonly string[];\n}\n\n/**\n * The HTML style-adapter hooks a pack may declare. Typed loosely here so `pack/` does not import `render/`.\n */\nexport type PackStyleAdapter = {\n  /** See {@link PrimitivePackInput.styleCollector}. */\n  styleCollector?: string;\n  /** The hooks of `HTMLStyleAdapter` from `./html`, erased: a fresh collector per render, the context renderers receive, and the stylesheet the collector produced. */\n  createCollector: (...args: never[]) => object;\n  createRenderContext: (...args: never[]) => unknown;\n  renderStyles: (...args: never[]) => string;\n  /**\n   * Whether `handle` belongs to this adapter's stylesheet. Required for a runtime to combine several packs' CSS: without it their handles cannot be routed and the host must pick one adapter.\n   */\n  ownsHandle?: (handle: StyleHandle) => boolean;\n};\n\n/** What a pack author passes to {@link definePrimitivePack}. */\nexport interface PrimitivePackInput {\n  /** Stable identifier, used in capability reports and error messages. */\n  id: string;\n  /**\n   * The optional surfaces this pack's primitives implement.\n   *\n   * Only `slack`, and it stays optional per primitive: the dispatcher converts\n   * the mandatory markdown to Block Kit, so declaring it reports an intent\n   * rather than imposing a requirement. Omit it entirely for a pack that\n   * renders Slack through that fallback.\n   */\n  surfaces?: readonly OptionalSurface[];\n  /** This pack's vocabulary. Node types must be unique within it, or construction throws. */\n  primitives: readonly AnyPrimitiveDefinition[];\n  /**\n   * Progressive enhancements this pack's primitives can apply, by id.\n   *\n   * Declared by the pack because an enhancement is a fact about its\n   * vocabulary — a sortable table, a copyable code block — and a host\n   * composing packs it did not write cannot be expected to know the ids.\n   * The runtime flattens these across packs; duplicate ids are rejected.\n   */\n  enhancements?: readonly EnhancementDefinition[];\n  /**\n   * Types that render as a self-contained picture rather than as text.\n   *\n   * A channel that cannot draw them inline uploads an image instead: the Slack\n   * dispatcher swaps such a node for an `image` block and an upload request, so\n   * a chart arrives as a PNG rather than as a markdown approximation of one.\n   *\n   * Declared by the pack because it is a fact about the vocabulary, and a host\n   * composing packs it did not write cannot be expected to know it.\n   */\n  slackAssetTypes?: readonly string[];\n  /**\n   * Default HTML style adapter for this pack. A runtime that omits\n   * `styleAdapter` runs the packs' own adapters, combined when more than one\n   * pack declares one and each answers `ownsHandle`. Pass `styleAdapter` on\n   * the runtime to replace them all.\n   */\n  styleAdapter?: PackStyleAdapter;\n  /**\n   * Names the collector shape this pack's `collectStyles` hooks mutate, so a\n   * runtime can reject a pack paired with an adapter of a different tag.\n   * Defaults to `styleAdapter.styleCollector`; a pack with neither opts out of\n   * the check.\n   */\n  styleCollector?: string;\n  /**\n   * This pack's own contribution to the runtime's authoring JSON Schema.\n   *\n   * Merged across every composed pack, so a host does not hand-merge each\n   * pack's `describe`/`omitProperties` into one options object itself. The\n   * runtime-level `authoring` option is merged in last and wins on conflict.\n   */\n  authoring?: PackAuthoringOptions;\n}\n\n/**\n * A pack as the runtime sees it.\n *\n * `TTheme` is the palette this pack's `react` renderers read as `env.theme`\n * when drawn through the `snapshot` surface — a *lower bound* on whatever theme\n * the runtime holding it supplies. It is carried by\n * {@link PrimitivePack.__theme} rather than by any real field, because\n * `primitives` is erased to `AnyPrimitiveDefinition[]` and a heterogeneous\n * inventory has no single node type to be generic over.\n *\n * The bound is declared, not derived: nothing checks it against what the\n * renderers actually read. State it at the definition as\n * `definePrimitivePack<T>(input)`.\n * Bare `PrimitivePack` requires nothing and fits any runtime; a slot that must\n * hold packs of every palette is typed {@link AnyPrimitivePack}.\n */\nexport interface PrimitivePack<TTheme = unknown> {\n  /** Unique among the packs a runtime composes, and used in error messages. */\n  readonly id: string;\n  /** See {@link PrimitivePackInput.surfaces}. */\n  readonly surfaces: readonly OptionalSurface[];\n  /** See {@link PrimitivePackInput.primitives}. */\n  readonly primitives: readonly AnyPrimitiveDefinition[];\n  /** Node types this pack owns, for duplicate detection across packs. */\n  readonly types: ReadonlySet<string>;\n  /**\n   * Each primitive's `icon` by type, for the primitives that declare one, so a host listing them need not walk `primitives`.\n   *\n   * A frozen null-prototype dictionary: an absent type reads `undefined`, even `constructor`. Absent on a pack built by an SDK that predates icons; {@link iconsByType} derives it from `primitives`.\n   */\n  readonly icons?: Readonly<Record<string, PrimitiveIcon>>;\n  /** See {@link PrimitivePackInput.enhancements}. */\n  readonly enhancements: readonly EnhancementDefinition[];\n  /** See {@link PrimitivePackInput.slackAssetTypes}. */\n  readonly slackAssetTypes: ReadonlySet<string>;\n  /** See {@link PrimitivePackInput.styleAdapter}. */\n  readonly styleAdapter?: PackStyleAdapter;\n  /** See {@link PrimitivePackInput.styleCollector}. */\n  readonly styleCollector?: string;\n  /** See {@link PrimitivePackInput.authoring}. */\n  readonly authoring?: PackAuthoringOptions;\n  /**\n   * Phantom: never present at runtime, never read.\n   *\n   * A property rather than a method so `strictFunctionTypes` checks it\n   * contravariantly. A method signature is bivariant, which would let a pack\n   * needing richer tokens sit in a slot supplying fewer and then read a field\n   * nothing supplies — the exact failure this marker exists to prevent.\n   */\n  readonly __theme?: (theme: TTheme) => void;\n}\n\n/**\n * A pack of any palette, for storage positions: `never` is assignable to every\n * requirement, so a slot typed this way holds every pack.\n */\nexport type AnyPrimitivePack = PrimitivePack<never>;\n\n/**\n * Builds a {@link PrimitivePack}.\n *\n * `TTheme` is the palette a frame must supply for this pack's nodes to be drawn\n * on the `snapshot` surface: `definePrimitivePack<CoreTokens>(input)`. Omitted, it is\n * `unknown`, which requires nothing.\n */\nexport const definePrimitivePack = <TTheme = unknown>(\n  input: PrimitivePackInput\n): PrimitivePack<TTheme> => {\n  if (input.primitives.length === 0) {\n    throw new IsomerError(\n      'EMPTY_PACK',\n      `primitive pack \"${input.id}\": at least one primitive is required`\n    );\n  }\n  assertUniquePrimitiveTypes(input.id, input.primitives);\n  assertUniqueEnhancementIds(input.id, input.enhancements ?? []);\n  const types = new Set(input.primitives.map((definition) => definition.type));\n  assertGroupedOnce(input.id, input.authoring?.groups ?? [], types);\n  for (const type of input.slackAssetTypes ?? []) {\n    if (!types.has(type)) {\n      throw new IsomerError(\n        'UNKNOWN_PRIMITIVE_TYPE',\n        `primitive pack \"${input.id}\": slackAssetTypes names primitive type \"${type}\", which the pack does not register`\n      );\n    }\n  }\n  const styleCollector =\n    input.styleCollector ?? input.styleAdapter?.styleCollector;\n\n  return {\n    id: input.id,\n    surfaces: input.surfaces ?? [],\n    primitives: input.primitives,\n    types,\n    icons: iconsByType(input.primitives),\n    enhancements: input.enhancements ?? [],\n    slackAssetTypes: new Set(input.slackAssetTypes ?? []),\n    ...(input.styleAdapter !== undefined\n      ? { styleAdapter: input.styleAdapter }\n      : {}),\n    ...(styleCollector !== undefined ? { styleCollector } : {}),\n    ...(input.authoring !== undefined ? { authoring: input.authoring } : {}),\n  };\n};\n\n/** Each definition's `icon` by type, null-prototype so a type such as `__proto__` is an ordinary key. */\nexport const iconsByType = (\n  primitives: readonly AnyPrimitiveDefinition[]\n): Readonly<Record<string, PrimitiveIcon>> => {\n  const icons = Object.create(null) as Record<string, PrimitiveIcon>;\n  for (const { type, icon } of primitives) {\n    if (icon !== undefined) {\n      icons[type] = icon;\n    }\n  }\n  return Object.freeze(icons);\n};\n\n/** Throws if `primitives` repeats a type. */\nconst assertUniquePrimitiveTypes = (\n  id: string,\n  primitives: readonly AnyPrimitiveDefinition[]\n): void => {\n  const seen = new Set<string>();\n  for (const { type } of primitives) {\n    if (seen.has(type)) {\n      throw new IsomerError(\n        'DUPLICATE_PRIMITIVE_TYPE',\n        `primitive pack \"${id}\": primitive type \"${type}\" registered twice`\n      );\n    }\n    seen.add(type);\n  }\n};\n\n/** Throws if a group names a type outside `types`, or two groups share a type. */\nconst assertGroupedOnce = (\n  id: string,\n  groups: readonly PrimitiveGroup[],\n  types: ReadonlySet<string>\n): void => {\n  const grouped = new Set<string>();\n  for (const { title, types: members } of groups) {\n    for (const type of members) {\n      if (!types.has(type)) {\n        throw new IsomerError(\n          'UNKNOWN_PRIMITIVE_TYPE',\n          `primitive pack \"${id}\": group \"${title}\" names primitive type \"${type}\", which the pack does not register`\n        );\n      }\n      if (grouped.has(type)) {\n        throw new IsomerError(\n          'DUPLICATE_PRIMITIVE_TYPE',\n          `primitive pack \"${id}\": primitive type \"${type}\" is in two groups`\n        );\n      }\n      grouped.add(type);\n    }\n  }\n};\n\n/** Throws if this pack registers the same enhancement id twice. */\nconst assertUniqueEnhancementIds = (\n  id: string,\n  enhancements: readonly EnhancementDefinition[]\n): void => {\n  const seen = new Set<string>();\n  for (const definition of enhancements) {\n    if (seen.has(definition.id)) {\n      throw new IsomerError(\n        'DUPLICATE_ENHANCEMENT',\n        `primitive pack \"${id}\": enhancement \"${definition.id}\" registered twice`\n      );\n    }\n    seen.add(definition.id);\n  }\n};\n"]}

package/dist/render/anchors.d.ts

@@ -0,0 +1,82 @@
+import { type ChildNodeWalker } from '../composition/body_node_base.js';
+/** The attribute {@link nodeAnchor} sets to a node's type, escaped so HTML parsing leaves it unchanged. */
+export declare const NODE_ANCHOR_ATTRIBUTE = "data-isomer-node";
+/**
+ * A node type as its anchor carries it. Every character outside `[A-Za-z0-9_-]`
+ * becomes `%<hex code point>;`, so the value survives HTML serialization and
+ * parsing unchanged and never throws. A plain identifier stays as it is.
+ */
+export declare const anchorValue: (type: string) => string;
+/**
+ * Runs `render` with anchors on or off for every {@link nodeAnchor} it reaches,
+ * whatever each render context says. The render must be synchronous; the
+ * previous state comes back afterwards, even if it throws.
+ */
+export declare const withAnchors: <TResult>(on: boolean, render: () => TResult) => TResult;
+/**
+ * `context` for content a renderer draws that is not one of its `children`,
+ * such as an embedded composition: nothing under it renders an anchor.
+ *
+ * The result is a view of `context`, not a copy: reads go to `context` itself,
+ * with methods bound to it, so getters, methods, private state, and
+ * `instanceof` behave as before. The mark survives a context derived from it
+ * by spreading. A context that is neither an object nor a function is
+ * returned as it is.
+ */
+export declare const withoutAnchors: <TContext>(context: TContext) => TContext;
+/**
+ * `context` with node anchors on, as an enhancement declaring `anchors: true`
+ * turns them on. A view like {@link withoutAnchors}, which still wins.
+ */
+export declare const withNodeAnchors: <TContext>(context: TContext) => TContext;
+/**
+ * Props a `react` renderer spreads on its root element so runtime code can find
+ * the node with {@link findNodeElementPairs}. Inside an HTML surface render the
+ * surface decides; elsewhere, on the React and `snapshot` surfaces, `context.anchors`
+ * does. Always empty under {@link withoutAnchors}.
+ */
+export declare const nodeAnchor: (context: unknown, { type }: {
+    type: string;
+}) => Readonly<Record<string, string>>;
+/** The attribute {@link layoutRoom} sets. */
+export declare const LAYOUT_ROOM_ATTRIBUTE = "data-isomer-room";
+/**
+ * Props a renderer spreads on an element inside its node that bounds the nodes
+ * nested in it, such as a frame's body, so `checkLayout` measures them against
+ * it. Rendered when {@link nodeAnchor} would be.
+ */
+export declare const layoutRoom: (context: unknown) => Readonly<Record<string, string>>;
+/**
+ * The nodes of `body` a render on `surface` draws, pre-order, each with its
+ * path in validation's `body[0].items[1]` form. Nested nodes follow `react`,
+ * as a container renders them through `renderReact` on either surface.
+ */
+export declare const anchoredNodePaths: (body: readonly unknown[], walk: ChildNodeWalker, surface?: "react" | "snapshot") => {
+    node: unknown;
+    path: string;
+}[];
+/** The `react`-visible nodes of `body`, pre-order: the order their anchors render in. */
+export declare const anchoredNodes: (body: readonly unknown[], walk: ChildNodeWalker) => unknown[];
+/** A node's `type`, when it has one. */
+export declare const nodeType: (node: unknown) => string | undefined;
+/**
+ * The item each of `nodes` pairs with, from `anchored` in document order: the
+ * k-th node of a type pairs with the k-th item whose anchor value is that
+ * type's. A type whose node and item counts disagree pairs with nothing.
+ */
+export declare const pairAnchors: <TItem>(anchored: Iterable<readonly [value: string, item: TItem]>, nodes: readonly unknown[]) => (TItem | undefined)[];
+/**
+ * Every `react`-visible node of `body`, walked pre-order, with the element
+ * its anchor marks under `root`, paired by {@link pairAnchors}. `root` holds
+ * one render.
+ *
+ * Pairing holds because every renderer draws its `children` in the order its
+ * definition's `children` returns them. A node that rendered nothing leaves
+ * its type unpaired. A node object that appears twice appears twice here,
+ * each time with its own element.
+ */
+export declare const findNodeElementPairs: (root: ParentNode, body: readonly unknown[], walk: ChildNodeWalker) => {
+    node: unknown;
+    element: Element | undefined;
+}[];
+//# sourceMappingURL=anchors.d.ts.map

package/dist/render/anchors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchors.d.ts","sourceRoot":"","sources":["../../src/render/anchors.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,+BAA+B,CAAC;AAIvC,2GAA2G;AAC3G,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,MACmC,CAAC;AAgB/E;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,EACjC,IAAI,OAAO,EACX,QAAQ,MAAM,OAAO,KACpB,OAaF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,EAAE,SAAS,QAAQ,KAAG,QACrB,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,EAAE,SAAS,QAAQ,KAAG,QACvB,CAAC;AAaxC;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GACrB,SAAS,OAAO,EAChB,UAAU;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,KACzB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CACwC,CAAC;AAE3E,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,UAAU,GACrB,SAAS,OAAO,KACf,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CACyB,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,SAAS,OAAO,EAAE,EACxB,MAAM,eAAe,EACrB,UAAS,OAAO,GAAG,UAAoB,KACtC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAejC,CAAC;AAEF,yFAAyF;AACzF,eAAO,MAAM,aAAa,GACxB,MAAM,SAAS,OAAO,EAAE,EACxB,MAAM,eAAe,KACpB,OAAO,EAA2D,CAAC;AAEtE,wCAAwC;AACxC,eAAO,MAAM,QAAQ,GAAI,MAAM,OAAO,KAAG,MAAM,GAAG,SAGjD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,EAC/B,UAAU,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,EACzD,OAAO,SAAS,OAAO,EAAE,KACxB,CAAC,KAAK,GAAG,SAAS,CAAC,EAyBrB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAM,UAAU,EAChB,MAAM,SAAS,OAAO,EAAE,EACxB,MAAM,eAAe,KACpB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,EAYjD,CAAC"}

package/dist/render/anchors.js

@@ -0,0 +1,153 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+import { childNodePath, isVisibleOnSurface, } from '../composition/body_node_base.js';
+import { contextWith, isObjectLike } from './context_view.js';
+/** The attribute {@link nodeAnchor} sets to a node's type, escaped so HTML parsing leaves it unchanged. */
+export const NODE_ANCHOR_ATTRIBUTE = 'data-isomer-node';
+/**
+ * A node type as its anchor carries it. Every character outside `[A-Za-z0-9_-]`
+ * becomes `%<hex code point>;`, so the value survives HTML serialization and
+ * parsing unchanged and never throws. A plain identifier stays as it is.
+ */
+export const anchorValue = (type) => type.replace(/[^\w-]/gu, (char) => `%${char.codePointAt(0).toString(16)};`);
+/** Marks a context whose subtree renders no anchors; see {@link withoutAnchors}. */
+const NO_ANCHORS = Symbol.for('elastic.isomer.anchors_off');
+/**
+ * Where an HTML render keeps its anchor decision while it runs. On `globalThis`
+ * under a `Symbol.for` key, so an ESM and a CommonJS copy of the SDK share it.
+ */
+const ACTIVE = Symbol.for('elastic.isomer.anchors_active');
+const activeAnchors = () => globalThis[ACTIVE];
+/**
+ * Runs `render` with anchors on or off for every {@link nodeAnchor} it reaches,
+ * whatever each render context says. The render must be synchronous; the
+ * previous state comes back afterwards, even if it throws.
+ */
+export const withAnchors = (on, render) => {
+    const scope = globalThis;
+    const outer = scope[ACTIVE];
+    scope[ACTIVE] = on;
+    try {
+        return render();
+    }
+    finally {
+        if (outer === undefined) {
+            delete scope[ACTIVE];
+        }
+        else {
+            scope[ACTIVE] = outer;
+        }
+    }
+};
+/**
+ * `context` for content a renderer draws that is not one of its `children`,
+ * such as an embedded composition: nothing under it renders an anchor.
+ *
+ * The result is a view of `context`, not a copy: reads go to `context` itself,
+ * with methods bound to it, so getters, methods, private state, and
+ * `instanceof` behave as before. The mark survives a context derived from it
+ * by spreading. A context that is neither an object nor a function is
+ * returned as it is.
+ */
+export const withoutAnchors = (context) => contextWith(context, NO_ANCHORS, true);
+/**
+ * `context` with node anchors on, as an enhancement declaring `anchors: true`
+ * turns them on. A view like {@link withoutAnchors}, which still wins.
+ */
+export const withNodeAnchors = (context) => contextWith(context, 'anchors', true);
+const anchorsOn = (context) => {
+    const carries = isObjectLike(context);
+    if (carries && Reflect.get(context, NO_ANCHORS) === true) {
+        return false;
+    }
+    return (activeAnchors() ??
+        (carries && context.anchors === true));
+};
+/**
+ * Props a `react` renderer spreads on its root element so runtime code can find
+ * the node with {@link findNodeElementPairs}. Inside an HTML surface render the
+ * surface decides; elsewhere, on the React and `snapshot` surfaces, `context.anchors`
+ * does. Always empty under {@link withoutAnchors}.
+ */
+export const nodeAnchor = (context, { type }) => anchorsOn(context) ? { [NODE_ANCHOR_ATTRIBUTE]: anchorValue(type) } : {};
+/** The attribute {@link layoutRoom} sets. */
+export const LAYOUT_ROOM_ATTRIBUTE = 'data-isomer-room';
+/**
+ * Props a renderer spreads on an element inside its node that bounds the nodes
+ * nested in it, such as a frame's body, so `checkLayout` measures them against
+ * it. Rendered when {@link nodeAnchor} would be.
+ */
+export const layoutRoom = (context) => anchorsOn(context) ? { [LAYOUT_ROOM_ATTRIBUTE]: '' } : {};
+/**
+ * The nodes of `body` a render on `surface` draws, pre-order, each with its
+ * path in validation's `body[0].items[1]` form. Nested nodes follow `react`,
+ * as a container renders them through `renderReact` on either surface.
+ */
+export const anchoredNodePaths = (body, walk, surface = 'react') => {
+    const visit = (node, path) => [
+        { node, path },
+        ...walk(node).flatMap((child) => isVisibleOnSurface(child.node, 'react')
+            ? visit(child.node, childNodePath(path, child.path))
+            : []),
+    ];
+    return body.flatMap((node, index) => isVisibleOnSurface(node, surface) ? visit(node, `body[${index}]`) : []);
+};
+/** The `react`-visible nodes of `body`, pre-order: the order their anchors render in. */
+export const anchoredNodes = (body, walk) => anchoredNodePaths(body, walk).map(({ node }) => node);
+/** A node's `type`, when it has one. */
+export const nodeType = (node) => {
+    const { type } = node;
+    return typeof type === 'string' ? type : undefined;
+};
+/**
+ * The item each of `nodes` pairs with, from `anchored` in document order: the
+ * k-th node of a type pairs with the k-th item whose anchor value is that
+ * type's. A type whose node and item counts disagree pairs with nothing.
+ */
+export const pairAnchors = (anchored, nodes) => {
+    const itemsByValue = new Map();
+    for (const [value, item] of anchored) {
+        const items = itemsByValue.get(value) ?? [];
+        items.push(item);
+        itemsByValue.set(value, items);
+    }
+    const counts = new Map();
+    for (const node of nodes) {
+        const type = nodeType(node);
+        if (type !== undefined) {
+            counts.set(type, (counts.get(type) ?? 0) + 1);
+        }
+    }
+    const seen = new Map();
+    return nodes.map((node) => {
+        const type = nodeType(node);
+        if (type === undefined) {
+            return undefined;
+        }
+        const index = seen.get(type) ?? 0;
+        seen.set(type, index + 1);
+        const items = itemsByValue.get(anchorValue(type)) ?? [];
+        return items.length === counts.get(type) ? items[index] : undefined;
+    });
+};
+/**
+ * Every `react`-visible node of `body`, walked pre-order, with the element
+ * its anchor marks under `root`, paired by {@link pairAnchors}. `root` holds
+ * one render.
+ *
+ * Pairing holds because every renderer draws its `children` in the order its
+ * definition's `children` returns them. A node that rendered nothing leaves
+ * its type unpaired. A node object that appears twice appears twice here,
+ * each time with its own element.
+ */
+export const findNodeElementPairs = (root, body, walk) => {
+    const nodes = anchoredNodes(body, walk);
+    // Read by attribute value, so a type is never read as selector syntax.
+    const elements = pairAnchors(Array.from(root.querySelectorAll(`[${NODE_ANCHOR_ATTRIBUTE}]`), (element) => [element.getAttribute(NODE_ANCHOR_ATTRIBUTE) ?? '', element]), nodes);
+    return nodes.map((node, index) => ({ node, element: elements[index] }));
+};
+//# sourceMappingURL=anchors.js.map

package/dist/render/anchors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchors.js","sourceRoot":"","sources":["../../src/render/anchors.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one\n * or more contributor license agreements. Licensed under the Elastic License\n * 2.0; you may not use this file except in compliance with the Elastic License\n * 2.0.\n */\n\nimport {\n  childNodePath,\n  type ChildNodeWalker,\n  isVisibleOnSurface,\n} from '../composition/body_node_base';\n\nimport { contextWith, isObjectLike } from './context_view';\n\n/** The attribute {@link nodeAnchor} sets to a node's type, escaped so HTML parsing leaves it unchanged. */\nexport const NODE_ANCHOR_ATTRIBUTE = 'data-isomer-node';\n\n/**\n * A node type as its anchor carries it. Every character outside `[A-Za-z0-9_-]`\n * becomes `%<hex code point>;`, so the value survives HTML serialization and\n * parsing unchanged and never throws. A plain identifier stays as it is.\n */\nexport const anchorValue = (type: string): string =>\n  type.replace(/[^\\w-]/gu, (char) => `%${char.codePointAt(0)!.toString(16)};`);\n\n/** Marks a context whose subtree renders no anchors; see {@link withoutAnchors}. */\nconst NO_ANCHORS = Symbol.for('elastic.isomer.anchors_off');\n\n/**\n * Where an HTML render keeps its anchor decision while it runs. On `globalThis`\n * under a `Symbol.for` key, so an ESM and a CommonJS copy of the SDK share it.\n */\nconst ACTIVE = Symbol.for('elastic.isomer.anchors_active');\n\ntype AnchorScope = { [ACTIVE]?: boolean };\n\nconst activeAnchors = (): boolean | undefined =>\n  (globalThis as AnchorScope)[ACTIVE];\n\n/**\n * Runs `render` with anchors on or off for every {@link nodeAnchor} it reaches,\n * whatever each render context says. The render must be synchronous; the\n * previous state comes back afterwards, even if it throws.\n */\nexport const withAnchors = <TResult>(\n  on: boolean,\n  render: () => TResult\n): TResult => {\n  const scope = globalThis as AnchorScope;\n  const outer = scope[ACTIVE];\n  scope[ACTIVE] = on;\n  try {\n    return render();\n  } finally {\n    if (outer === undefined) {\n      delete scope[ACTIVE];\n    } else {\n      scope[ACTIVE] = outer;\n    }\n  }\n};\n\n/**\n * `context` for content a renderer draws that is not one of its `children`,\n * such as an embedded composition: nothing under it renders an anchor.\n *\n * The result is a view of `context`, not a copy: reads go to `context` itself,\n * with methods bound to it, so getters, methods, private state, and\n * `instanceof` behave as before. The mark survives a context derived from it\n * by spreading. A context that is neither an object nor a function is\n * returned as it is.\n */\nexport const withoutAnchors = <TContext>(context: TContext): TContext =>\n  contextWith(context, NO_ANCHORS, true);\n\n/**\n * `context` with node anchors on, as an enhancement declaring `anchors: true`\n * turns them on. A view like {@link withoutAnchors}, which still wins.\n */\nexport const withNodeAnchors = <TContext>(context: TContext): TContext =>\n  contextWith(context, 'anchors', true);\n\nconst anchorsOn = (context: unknown): boolean => {\n  const carries = isObjectLike(context);\n  if (carries && Reflect.get(context, NO_ANCHORS) === true) {\n    return false;\n  }\n  return (\n    activeAnchors() ??\n    (carries && (context as { anchors?: unknown }).anchors === true)\n  );\n};\n\n/**\n * Props a `react` renderer spreads on its root element so runtime code can find\n * the node with {@link findNodeElementPairs}. Inside an HTML surface render the\n * surface decides; elsewhere, on the React and `snapshot` surfaces, `context.anchors`\n * does. Always empty under {@link withoutAnchors}.\n */\nexport const nodeAnchor = (\n  context: unknown,\n  { type }: { type: string }\n): Readonly<Record<string, string>> =>\n  anchorsOn(context) ? { [NODE_ANCHOR_ATTRIBUTE]: anchorValue(type) } : {};\n\n/** The attribute {@link layoutRoom} sets. */\nexport const LAYOUT_ROOM_ATTRIBUTE = 'data-isomer-room';\n\n/**\n * Props a renderer spreads on an element inside its node that bounds the nodes\n * nested in it, such as a frame's body, so `checkLayout` measures them against\n * it. Rendered when {@link nodeAnchor} would be.\n */\nexport const layoutRoom = (\n  context: unknown\n): Readonly<Record<string, string>> =>\n  anchorsOn(context) ? { [LAYOUT_ROOM_ATTRIBUTE]: '' } : {};\n\n/**\n * The nodes of `body` a render on `surface` draws, pre-order, each with its\n * path in validation's `body[0].items[1]` form. Nested nodes follow `react`,\n * as a container renders them through `renderReact` on either surface.\n */\nexport const anchoredNodePaths = (\n  body: readonly unknown[],\n  walk: ChildNodeWalker,\n  surface: 'react' | 'snapshot' = 'react'\n): { node: unknown; path: string }[] => {\n  const visit = (\n    node: unknown,\n    path: string\n  ): { node: unknown; path: string }[] => [\n    { node, path },\n    ...walk(node).flatMap((child) =>\n      isVisibleOnSurface(child.node, 'react')\n        ? visit(child.node, childNodePath(path, child.path))\n        : []\n    ),\n  ];\n  return body.flatMap((node, index) =>\n    isVisibleOnSurface(node, surface) ? visit(node, `body[${index}]`) : []\n  );\n};\n\n/** The `react`-visible nodes of `body`, pre-order: the order their anchors render in. */\nexport const anchoredNodes = (\n  body: readonly unknown[],\n  walk: ChildNodeWalker\n): unknown[] => anchoredNodePaths(body, walk).map(({ node }) => node);\n\n/** A node's `type`, when it has one. */\nexport const nodeType = (node: unknown): string | undefined => {\n  const { type } = node as { type?: unknown };\n  return typeof type === 'string' ? type : undefined;\n};\n\n/**\n * The item each of `nodes` pairs with, from `anchored` in document order: the\n * k-th node of a type pairs with the k-th item whose anchor value is that\n * type's. A type whose node and item counts disagree pairs with nothing.\n */\nexport const pairAnchors = <TItem>(\n  anchored: Iterable<readonly [value: string, item: TItem]>,\n  nodes: readonly unknown[]\n): (TItem | undefined)[] => {\n  const itemsByValue = new Map<string, TItem[]>();\n  for (const [value, item] of anchored) {\n    const items = itemsByValue.get(value) ?? [];\n    items.push(item);\n    itemsByValue.set(value, items);\n  }\n  const counts = new Map<string, number>();\n  for (const node of nodes) {\n    const type = nodeType(node);\n    if (type !== undefined) {\n      counts.set(type, (counts.get(type) ?? 0) + 1);\n    }\n  }\n  const seen = new Map<string, number>();\n  return nodes.map((node) => {\n    const type = nodeType(node);\n    if (type === undefined) {\n      return undefined;\n    }\n    const index = seen.get(type) ?? 0;\n    seen.set(type, index + 1);\n    const items = itemsByValue.get(anchorValue(type)) ?? [];\n    return items.length === counts.get(type) ? items[index] : undefined;\n  });\n};\n\n/**\n * Every `react`-visible node of `body`, walked pre-order, with the element\n * its anchor marks under `root`, paired by {@link pairAnchors}. `root` holds\n * one render.\n *\n * Pairing holds because every renderer draws its `children` in the order its\n * definition's `children` returns them. A node that rendered nothing leaves\n * its type unpaired. A node object that appears twice appears twice here,\n * each time with its own element.\n */\nexport const findNodeElementPairs = (\n  root: ParentNode,\n  body: readonly unknown[],\n  walk: ChildNodeWalker\n): { node: unknown; element: Element | undefined }[] => {\n  const nodes = anchoredNodes(body, walk);\n  // Read by attribute value, so a type is never read as selector syntax.\n  const elements = pairAnchors(\n    Array.from(\n      root.querySelectorAll(`[${NODE_ANCHOR_ATTRIBUTE}]`),\n      (element) =>\n        [element.getAttribute(NODE_ANCHOR_ATTRIBUTE) ?? '', element] as const\n    ),\n    nodes\n  );\n  return nodes.map((node, index) => ({ node, element: elements[index] }));\n};\n"]}

package/dist/render/context_view.d.ts

@@ -0,0 +1,10 @@
+/** Whether `value` can carry properties: a non-null object or a function. */
+export declare const isObjectLike: (value: unknown) => value is object;
+/**
+ * A view of `context` that reads `key` as `value` and everything else from
+ * `context`, with methods bound to it, so getters, private state, and
+ * `instanceof` behave as before, and a callable context stays callable. A
+ * context that is neither an object nor a function is returned as it is.
+ */
+export declare const contextWith: <TContext>(context: TContext, key: string | symbol, value: unknown) => TContext;
+//# sourceMappingURL=context_view.d.ts.map

package/dist/render/context_view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context_view.d.ts","sourceRoot":"","sources":["../../src/render/context_view.ts"],"names":[],"mappings":"AAOA,6EAA6E;AAC7E,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACuB,CAAC;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,EAClC,SAAS,QAAQ,EACjB,KAAK,MAAM,GAAG,MAAM,EACpB,OAAO,OAAO,KACb,QAoCF,CAAC"}

package/dist/render/context_view.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+/** Whether `value` can carry properties: a non-null object or a function. */
+export const isObjectLike = (value) => (typeof value === 'object' && value !== null) || typeof value === 'function';
+/**
+ * A view of `context` that reads `key` as `value` and everything else from
+ * `context`, with methods bound to it, so getters, private state, and
+ * `instanceof` behave as before, and a callable context stays callable. A
+ * context that is neither an object nor a function is returned as it is.
+ */
+export const contextWith = (context, key, value) => {
+    if (!isObjectLike(context)) {
+        return context;
+    }
+    const original = context;
+    // An extensible stand-in, so a frozen context cannot trip the proxy invariants. An arrow function has no non-configurable own keys.
+    const prototype = Object.getPrototypeOf(original);
+    const standIn = (typeof original === 'function'
+        ? Object.setPrototypeOf(() => undefined, prototype)
+        : Object.create(prototype));
+    return new Proxy(standIn, {
+        apply: (_, self, args) => Reflect.apply(original, self, args),
+        get: (_, read) => {
+            if (read === key) {
+                return value;
+            }
+            const found = Reflect.get(original, read, original);
+            return typeof found === 'function'
+                ? found.bind(original)
+                : found;
+        },
+        set: (_, write, next) => Reflect.set(original, write, next, original),
+        has: (_, read) => read === key || Reflect.has(original, read),
+        ownKeys: () => [...new Set([...Reflect.ownKeys(original), key])],
+        getOwnPropertyDescriptor: (_, read) => {
+            if (read === key) {
+                return { value, enumerable: true, configurable: true, writable: true };
+            }
+            const descriptor = Reflect.getOwnPropertyDescriptor(original, read);
+            return descriptor && { ...descriptor, configurable: true };
+        },
+        getPrototypeOf: () => Object.getPrototypeOf(original),
+    });
+};
+//# sourceMappingURL=context_view.js.map

package/dist/render/context_view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context_view.js","sourceRoot":"","sources":["../../src/render/context_view.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,6EAA6E;AAC7E,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAc,EAAmB,EAAE,CAC9D,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC,IAAI,OAAO,KAAK,KAAK,UAAU,CAAC;AAE/E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,OAAiB,EACjB,GAAoB,EACpB,KAAc,EACJ,EAAE;IACZ,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,MAAM,QAAQ,GAAG,OAAO,CAAC;IACzB,oIAAoI;IACpI,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAkB,CAAC;IACnE,MAAM,OAAO,GAAG,CACd,OAAO,QAAQ,KAAK,UAAU;QAC5B,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC;QACnD,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CACnB,CAAC;IACZ,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE;QACxB,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAe,EAAE,EAAE,CAClC,OAAO,CAAC,KAAK,CAAC,QAA2C,EAAE,IAAI,EAAE,IAAI,CAAC;QACxE,GAAG,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE;YACf,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBACjB,OAAO,KAAK,CAAC;YACf,CAAC;YACD,MAAM,KAAK,GAAY,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;YAC7D,OAAO,OAAO,KAAK,KAAK,UAAU;gBAChC,CAAC,CAAE,KAAyC,CAAC,IAAI,CAAC,QAAQ,CAAC;gBAC3D,CAAC,CAAC,KAAK,CAAC;QACZ,CAAC;QACD,GAAG,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC;QACrE,GAAG,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC;QAC7D,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;QAChE,wBAAwB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE;YACpC,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBACjB,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;YACzE,CAAC;YACD,MAAM,UAAU,GAAG,OAAO,CAAC,wBAAwB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YACpE,OAAO,UAAU,IAAI,EAAE,GAAG,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;QAC7D,CAAC;QACD,cAAc,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAkB;KACvE,CAAa,CAAC;AACjB,CAAC,CAAC","sourcesContent":["/*\n * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one\n * or more contributor license agreements. Licensed under the Elastic License\n * 2.0; you may not use this file except in compliance with the Elastic License\n * 2.0.\n */\n\n/** Whether `value` can carry properties: a non-null object or a function. */\nexport const isObjectLike = (value: unknown): value is object =>\n  (typeof value === 'object' && value !== null) || typeof value === 'function';\n\n/**\n * A view of `context` that reads `key` as `value` and everything else from\n * `context`, with methods bound to it, so getters, private state, and\n * `instanceof` behave as before, and a callable context stays callable. A\n * context that is neither an object nor a function is returned as it is.\n */\nexport const contextWith = <TContext>(\n  context: TContext,\n  key: string | symbol,\n  value: unknown\n): TContext => {\n  if (!isObjectLike(context)) {\n    return context;\n  }\n  const original = context;\n  // An extensible stand-in, so a frozen context cannot trip the proxy invariants. An arrow function has no non-configurable own keys.\n  const prototype = Object.getPrototypeOf(original) as object | null;\n  const standIn = (\n    typeof original === 'function'\n      ? Object.setPrototypeOf(() => undefined, prototype)\n      : Object.create(prototype)\n  ) as object;\n  return new Proxy(standIn, {\n    apply: (_, self, args: unknown[]) =>\n      Reflect.apply(original as (...rest: unknown[]) => unknown, self, args),\n    get: (_, read) => {\n      if (read === key) {\n        return value;\n      }\n      const found: unknown = Reflect.get(original, read, original);\n      return typeof found === 'function'\n        ? (found as (...args: unknown[]) => unknown).bind(original)\n        : found;\n    },\n    set: (_, write, next) => Reflect.set(original, write, next, original),\n    has: (_, read) => read === key || Reflect.has(original, read),\n    ownKeys: () => [...new Set([...Reflect.ownKeys(original), key])],\n    getOwnPropertyDescriptor: (_, read) => {\n      if (read === key) {\n        return { value, enumerable: true, configurable: true, writable: true };\n      }\n      const descriptor = Reflect.getOwnPropertyDescriptor(original, read);\n      return descriptor && { ...descriptor, configurable: true };\n    },\n    getPrototypeOf: () => Object.getPrototypeOf(original) as object | null,\n  }) as TContext;\n};\n"]}

package/dist/render/format_display_value.d.ts

@@ -0,0 +1,20 @@
+import type { DisplayValue, StructuredValue } from '../composition/structured_value.js';
+/** Options for {@link formatDisplayValue}. */
+export interface FormatDisplayValueOptions {
+    /** Reference instant for `relativeTime`; defaults to the render time. */
+    now?: Date;
+}
+/** Narrows a {@link DisplayValue} to the object form. */
+export declare const isStructuredValue: (value: DisplayValue) => value is StructuredValue;
+/** The unformatted value behind a {@link DisplayValue}. */
+export declare const rawDisplayValue: (value: DisplayValue) => number | string;
+/**
+ * Renders a {@link DisplayValue} for display. A bare string passes through; a
+ * {@link StructuredValue} is formatted per its `format`.
+ *
+ * Numeric formats fall back to `String(raw)` for a string `raw` rather than
+ * erroring. Locale is fixed to `en-US` and dates render in UTC so the same
+ * composition formats identically on every host.
+ */
+export declare const formatDisplayValue: (value: DisplayValue, options?: FormatDisplayValueOptions) => string;
+//# sourceMappingURL=format_display_value.d.ts.map

package/dist/render/format_display_value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format_display_value.d.ts","sourceRoot":"","sources":["../../src/render/format_display_value.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EAChB,MAAM,iCAAiC,CAAC;AAIzC,8CAA8C;AAC9C,MAAM,WAAW,yBAAyB;IACxC,yEAAyE;IACzE,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAED,yDAAyD;AACzD,eAAO,MAAM,iBAAiB,GAC5B,OAAO,YAAY,KAClB,KAAK,IAAI,eACmD,CAAC;AAEhE,2DAA2D;AAC3D,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MAAM,GAAG,MACjB,CAAC;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,YAAY,EACnB,UAAS,yBAA8B,KACtC,MAqCF,CAAC"}

package/dist/render/format_display_value.js

@@ -0,0 +1,137 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+import { formatCompactNumber } from './format_number.js';
+/** Narrows a {@link DisplayValue} to the object form. */
+export const isStructuredValue = (value) => typeof value === 'object' && value !== null && 'raw' in value;
+/** The unformatted value behind a {@link DisplayValue}. */
+export const rawDisplayValue = (value) => isStructuredValue(value) ? value.raw : value;
+/**
+ * Renders a {@link DisplayValue} for display. A bare string passes through; a
+ * {@link StructuredValue} is formatted per its `format`.
+ *
+ * Numeric formats fall back to `String(raw)` for a string `raw` rather than
+ * erroring. Locale is fixed to `en-US` and dates render in UTC so the same
+ * composition formats identically on every host.
+ */
+export const formatDisplayValue = (value, options = {}) => {
+    if (!isStructuredValue(value)) {
+        return value;
+    }
+    const { raw, format, precision, currency } = value;
+    switch (format) {
+        case 'compact':
+            return typeof raw === 'number'
+                ? formatCompactNumber(raw, '', precision)
+                : String(raw);
+        case 'percent':
+            return typeof raw === 'number'
+                ? intlNumber(raw, precision, { style: 'percent' })
+                : String(raw);
+        case 'currency':
+            return typeof raw === 'number'
+                ? intlNumber(raw, precision ?? 2, {
+                    style: 'currency',
+                    currency: currency ?? 'USD',
+                })
+                : String(raw);
+        case 'bytes':
+            return typeof raw === 'number'
+                ? formatBytes(raw, precision)
+                : String(raw);
+        case 'duration':
+            return typeof raw === 'number' ? formatDuration(raw) : String(raw);
+        case 'date':
+            return formatDate(raw);
+        case 'relativeTime':
+            return formatRelativeTime(raw, options.now ?? new Date());
+        case 'number':
+        default:
+            return typeof raw === 'number'
+                ? intlNumber(raw, precision, {})
+                : String(raw);
+    }
+};
+const intlNumber = (value, precision, options) => new Intl.NumberFormat('en-US', {
+    ...options,
+    ...(precision === undefined
+        ? { maximumFractionDigits: 2 }
+        : {
+            minimumFractionDigits: precision,
+            maximumFractionDigits: precision,
+        }),
+}).format(value);
+const BYTE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+const formatBytes = (bytes, precision) => {
+    let scaled = Math.abs(bytes);
+    let unit = 0;
+    while (scaled >= 1024 && unit < BYTE_UNITS.length - 1) {
+        scaled /= 1024;
+        unit += 1;
+    }
+    const sign = bytes < 0 ? '-' : '';
+    const digits = unit === 0 ? 0 : (precision ?? 1);
+    return `${sign}${trimFixed(scaled, digits)} ${BYTE_UNITS[unit]}`;
+};
+const formatDuration = (seconds) => {
+    const abs = Math.abs(seconds);
+    const sign = seconds < 0 ? '-' : '';
+    if (abs < 1) {
+        return `${sign}${trimFixed(abs * 1000, 1)}ms`;
+    }
+    if (abs < 60) {
+        return `${sign}${trimFixed(abs, 1)}s`;
+    }
+    const pairs = [
+        [86400, 'd', 3600, 'h'],
+        [3600, 'h', 60, 'm'],
+        [60, 'm', 1, 's'],
+    ];
+    for (const [major, majorUnit, minor, minorUnit] of pairs) {
+        if (abs >= major) {
+            const majorCount = Math.floor(abs / major);
+            const minorCount = Math.floor((abs % major) / minor);
+            return minorCount > 0
+                ? `${sign}${majorCount}${majorUnit} ${minorCount}${minorUnit}`
+                : `${sign}${majorCount}${majorUnit}`;
+        }
+    }
+    return `${sign}${trimFixed(abs, 1)}s`;
+};
+const formatDate = (raw) => {
+    const date = new Date(raw);
+    if (Number.isNaN(date.getTime())) {
+        return String(raw);
+    }
+    return new Intl.DateTimeFormat('en-US', {
+        dateStyle: 'medium',
+        timeStyle: 'short',
+        timeZone: 'UTC',
+    }).format(date);
+};
+const formatRelativeTime = (raw, now) => {
+    const date = new Date(raw);
+    if (Number.isNaN(date.getTime())) {
+        return String(raw);
+    }
+    const deltaSeconds = Math.round((date.getTime() - now.getTime()) / 1000);
+    const abs = Math.abs(deltaSeconds);
+    if (abs < 45) {
+        return 'just now';
+    }
+    const unit = abs < 60 * 45
+        ? [Math.max(1, Math.round(abs / 60)), 'm']
+        : abs < 3600 * 22
+            ? [Math.max(1, Math.round(abs / 3600)), 'h']
+            : [Math.max(1, Math.round(abs / 86400)), 'd'];
+    const phrase = `${unit[0]}${unit[1]}`;
+    return deltaSeconds < 0 ? `${phrase} ago` : `in ${phrase}`;
+};
+const trimFixed = (value, digits) => {
+    const fixed = value.toFixed(digits);
+    return fixed.includes('.') ? fixed.replace(/\.?0+$/, '') : fixed;
+};
+//# sourceMappingURL=format_display_value.js.map