tungsten 0.7.0 → 0.7.2

package/dist/testing/ensure.js

@@ -1,11 +1,23 @@
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 import { styleText } from 'node:util';
 import deepEqual from 'deep-eql';
+import { warn } from '../output.js';
 import { ContentNodeElementIsComponent, ContentNodeElementIsHtml, ContentNodeIsArray, ContentNodeIsElement, ContentNodeIsLiteral, IsContentNode } from '../ContentNode.js';
-import { $fragment, $props, $type } from '../contentNodeSymbols.js';
+import { $props, $type } from '../contentNodeSymbols.js';
 import { componentTypeIdentityKey } from '../hmr/componentIdentity.js';
+import { display } from './display.js';
+// with: the match's properties; its tag, and text and elements it holds, are for children
+const propertyEnds = ['interruptedText', 'className', 'id', 'prop'];
 // exported after
 const _ensure = withMembers(ensure, quantifiers(fact => fact));
 export { _ensure as ensure }; // naming
@@ -22,32 +34,39 @@ export const {
   all,
   count
 } = _ensure;
-function quantifiers(finish) {
+// E: the ends as the caller offers them, which the built ends are typed loosely for.
+// properties: only the ends a with list takes
+function quantifiers(finish, properties = false) {
+  const made = (quantifier, requirement, spoken) => {
+    const all = ends(quantifier, requirement, finish, spoken);
+    const offered = properties ? Object.fromEntries(propertyEnds.map(name => [name, all[name]])) : all;
+    return offered; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+  };
   return {
     get no() {
-      return ends('no', counting(count => count === 0, 0), finish);
+      return made('no', counting(count => count === 0, 0));
     },
     get none() {
-      return ends('none', counting(count => count === 0, 0), finish, 'no');
+      return made('none', counting(count => count === 0, 0), 'no');
     },
     get one() {
-      return ends('one', counting(count => count === 1, 1), finish);
+      return made('one', counting(count => count === 1, 1));
     },
     get two() {
-      return ends('two', counting(count => count === 2, 2), finish);
+      return made('two', counting(count => count === 2, 2));
     },
     get three() {
-      return ends('three', counting(count => count === 3, 3), finish);
+      return made('three', counting(count => count === 3, 3));
     },
     get a() {
-      return ends('a', counting(count => count === 1, 1), finish);
+      return made('a', counting(count => count === 1, 1));
     },
     get an() {
-      return ends('an', counting(count => count === 1, 1), finish);
+      return made('an', counting(count => count === 1, 1));
     },
-    count: num => ends(`count(${num})`, counting(count => count === num, num), finish, String(num)),
+    count: num => made(`count(${num})`, counting(count => count === num, num), String(num)),
     get some() {
-      return ends('some', () => {
+      return made('some', () => {
         let count = 0;
         return [match => {
           if (match) ++count;
@@ -58,11 +77,11 @@ function quantifiers(finish) {
           saw: 'saw 0',
           showDiff: false
         }];
-      }, finish);
+      });
     },
     // every sighting of its kind must match, and there must be one: all of none proves nothing
     get all() {
-      return ends('all', () => {
+      return made('all', () => {
         let count = 0;
         return [match => {
           if (match) ++count;
@@ -72,7 +91,7 @@ function quantifiers(finish) {
           saw: `saw ${count} of ${ofKind}`,
           showDiff: ofKind > 0
         }];
-      }, finish, 'every');
+      }, 'every');
     }
   };
 }
@@ -82,7 +101,8 @@ const spokenList = facts => `(${facts.map(fact => fact[5]).join(' and ')})`;
 const jsxValue = value => typeof value === 'string' ? `"${value}"` : `{${display(value)}}`;
 // each end says only what a sighting must be, and how it reads in a failure;
 // ensure() starts the requirement
-// spoken: the quantifier as prose, where it differs - none as no, count(3) as 3
+// spoken: the quantifier as prose, where it differs - none as no, count(3) as 3.
+// Typed loosely, every end making a plain Fact; quantifiers() gives them their offered types
 function ends(quantifier, requirement, finish, spoken = quantifier) {
   const fact = (kind, test, end, prose, explain) => finish([kind, test, requirement, quantifier, end, `${spoken} ${prose}`, explain]);
   const many = !['one', 'a', 'an', 'every', '1'].includes(spoken);
@@ -95,12 +115,12 @@ function ends(quantifier, requirement, finish, spoken = quantifier) {
   };
   // alone: present. with: facts on the element itself, its children among them
   const element = (kind, end, prose, own) => {
-    const within = scoped(kind, end, prose, seen => own(seen));
+    const within = scoped(kind, end, prose, own);
     const below = scoped(kind, end, prose, childrenScope);
     const children = withMembers(facts => below(facts, `with.children(${listed(facts)})`, `with ${spokenList(facts)} in its children`), quantifiers(inner => below([inner], `with.children.${chained(inner)}`, `with ${inner[5]} in its children`)));
     return Object.assign(fact(kind, () => true, end, prose), {
       // facts, or a fn given the props for what facts cannot say
-      with: withMembers(withMembers(facts => Array.isArray(facts) ? within(facts, `with(${listed(facts)})`, `with ${spokenList(facts)}`) : fact(kind, seen => facts(seen), `${end}.with(${fnName(facts)})`, `${prose} passing ${fnName(facts)}`), quantifiers(inner => within([inner], `with.${chained(inner)}`, `with ${inner[5]}`))), {
+      with: withMembers(withMembers(facts => Array.isArray(facts) ? within(facts, `with(${listed(facts)})`, `with ${spokenList(facts)}`) : fact(kind, seen => facts(propsOf(seen)), `${end}.with(${fnName(facts)})`, `${prose} passing ${fnName(facts)}`), quantifiers(inner => within([inner], `with.${chained(inner)}`, `with ${inner[5]}`), true)), {
         children
       })
     });
@@ -119,8 +139,12 @@ function ends(quantifier, requirement, finish, spoken = quantifier) {
     text: stringEnd('text', 'text', 'text node'),
     textCi: stringEnd('text', 'textCi', 'text node', true),
     interruptedText: stringEnd('interruptedText', 'interruptedText', 'element text'),
-    html: tag => element(`html:${tag}`, `html('${tag}')`, `<${tag}>`, props => htmlOwnSightings(tag, props)),
-    component: name => element(`component:${name}`, `component('${name}')`, `<${name}>`, props => componentOwnSightings(name, props)),
+    html: tag => element(`html:${tag}`, `html('${tag}')`, `<${tag}>`, seen => htmlOwnSightings(tag, propsOf(seen))),
+    component: name => element(`component:${name}`, `component('${name}')`, `<${name}>`, seen => componentOwnSightings(name, propsOf(seen))),
+    select: query => {
+      selector(query); // an invalid selector throws here, as the fact is made
+      return element(`select:${query}`, `select('${query}')`, `'${query}' ${noun('element')}`, selectOwnSightings);
+    },
     fragment: () => fact('fragment', () => true, 'fragment()', noun('fragment')),
     className: className => fact('className', seen => className === undefined || seen === className, className === undefined ? 'className()' : `className('${className}')`, className === undefined ? noun('class') : `class="${className}"`),
     id: id => fact('id', seen => id === undefined || seen === id, id === undefined ? 'id()' : `id('${id}')`, id === undefined ? noun('id') : `id="${id}"`),
@@ -196,9 +220,17 @@ function tracked(sightings, facts) {
   for (const [kind, value] of sightings) {
     for (const fact of byKind.get(kind) ?? []) fact.track(fact.test(value));
   }
+  for (const [kind, kindFacts] of byKind) {
+    if (!isSelectKind(kind)) continue;
+    for (const [, value] of selectSightings(sightings, kind)) {
+      for (const fact of kindFacts) fact.track(fact.test(value));
+    }
+  }
   return started;
 }
-const ofKind = (sightings, kind) => sightings.filter(([seenKind]) => seenKind === kind).length;
+const isSelectKind = kind => kind.startsWith('select:');
+const sightingsOf = (sightings, kind) => isSelectKind(kind) ? selectSightings(sightings, kind) : sightings.filter(([seenKind]) => seenKind === kind);
+const ofKind = (sightings, kind) => sightingsOf(sightings, kind).length;
 // the first fact to fail, with what it saw.
 // Every fact decides, including those of a kind the tree never showed
 function check(sightings, facts) {
@@ -258,7 +290,7 @@ function explained(outcome, style) {
   }) => {
     if (fact.explain === undefined) return paint('red', `${label(fact)}: ${failure.saw}`);
     // a children fact's one sighting is its element, so listing it would repeat the element
-    const element = fact.operator === '' ? sightings.find(([kind]) => kind === fact.kind) : undefined;
+    const element = fact.operator === '' ? sightingsOf(sightings, fact.kind)[0] : undefined;
     const inner = element === undefined ? undefined : fact.explain(element[1]);
     if (inner !== undefined) {
       return `${readable ? 'in its children,' : 'children:'} ${explained(inner, style)}`;
@@ -275,14 +307,18 @@ const fnName = fn => fn.name === '' ? 'fn' : fn.name;
 const chained = ([,,, quantifier, end]) => quantifier === '' ? end : `${quantifier}.${end}`;
 const listed = facts => `[${facts.map(chained).join(', ')}]`;
 const childrenKind = 'children';
+const childrenScope = seen => contentSightings(propsOf(seen).children);
+// an element sighting's value is its props, or for a selector's, the element it matched
+const propsOf = seen =>
 // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-const childrenScope = seen => contentSightings(seen.children);
+seen instanceof SelectElement ? seen.props : seen;
 // a children fact takes the kind of the element whose with list holds it
 const forKind = (fact, kind) => fact[0] === childrenKind ? [kind, fact[1], fact[2], fact[3], fact[4], fact[5], fact[6]] : fact;
 // a with list holds one sighting of its element's kind - the element itself - so a children fact
 // passes where the element's content meets its inner facts
 function childrenFact(inner, end, spoken) {
-  return [childrenKind, scopeTest(childrenScope, inner), counting(count => count === 1, 1), '', end, `${spoken} in its children`, scopeExplain(childrenScope, inner)];
+  const fact = [childrenKind, scopeTest(childrenScope, inner), counting(count => count === 1, 1), '', end, `${spoken} in its children`, scopeExplain(childrenScope, inner)];
+  return fact; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
 }
 // the element's children as a tree, for a with list, beside the element's own facts:
 // with([one.className('x'), children.one.html('li')]), or with([children([…])]) for a list of them
@@ -339,9 +375,9 @@ function seenLine({
     readable,
     paint
   } = style;
-  const separator = top && /^(html|component):/.test(kind) ? '\n    ' : ', ';
+  const separator = top && /^(html|component|select):/.test(kind) ? '\n    ' : ', ';
   const named = readable ? spokenKind(kind) : kind;
-  const seen = sightings.filter(([seenKind]) => seenKind === kind).map(sighting => ({
+  const seen = sightingsOf(sightings, kind).map(sighting => ({
     sighting,
     outcome: explain?.(sighting[1])
   }));
@@ -367,6 +403,7 @@ const plural = named => named.endsWith('s') ? `${named}es` : `${named}s`;
 function spokenKind(kind) {
   const [family, name] = kind.split(/:(.*)/);
   if (family === 'html' || family === 'component') return `<${name}>`;
+  if (family === 'select') return `'${name}' element`;
   if (family === 'prop') return `${name} prop`;
   const plain = {
     text: 'text node',
@@ -378,44 +415,13 @@ function spokenKind(kind) {
 // an element as its tag or name and props, as written: <a href='/x'>
 function displaySighting([kind, value]) {
   if (kind === 'fragment') return '<>';
+  if (value instanceof SelectElement) return displayElement(value.name, value.props);
   const element = /^(?:html|component):(.*)$/.exec(kind)?.[1];
-  if (element === undefined) return display(value);
-  const props = Object.entries(value).filter(([name]) => name !== 'children').map(([name, prop]) => ` ${name}=${display(prop)}`);
-  return `<${element}${props.join('')}>`;
+  return element === undefined ? display(value) : displayElement(element, value);
 }
-const displayed = 5; // entries shown of an array or object
-const displayDepth = 2;
-// a value as a failure message shows it; arrays and objects shortened by length and depth
-function display(value, depth = 0) {
-  if (typeof value === 'string') return `'${value}'`;
-  if (typeof value === 'function') {
-    return value.name === '' ? '[function]' : `[function ${value.name}]`;
-  }
-  if (typeof value !== 'object' || value === null) {
-    return String(value); // a number, boolean, bigint, symbol, null or undefined
-  }
-  if (value instanceof Date) {
-    return isNaN(value.getTime()) ? 'Date(invalid)' : `Date(${value.toISOString()})`;
-  }
-  // an element held as a value, as in a prop: by tag or name, as its symbol keys hide it as data
-  if ($type in value && IsContentNode(value) && ContentNodeIsElement(value)) {
-    const type = value[$type];
-    if (type === $fragment) return '<>';
-    return `<${typeof type === 'string' ? type : componentTypeIdentityKey(type)}>`;
-  }
-  const shown = entries => depth >= displayDepth ? '…' : entries.slice(0, displayed).join(', ') + (entries.length > displayed ? ', …' : '');
-  if (Array.isArray(value)) {
-    return value.length === 0 ? '[]' : `[${shown(value.map(each => display(each, depth + 1)))}]`;
-  }
-  if (value instanceof Set) {
-    return `Set { ${shown([...value].map(each => display(each, depth + 1)))} }`;
-  }
-  if (value instanceof Map) {
-    const pairs = [...value].map(([key, each]) => `${display(key, depth + 1)} => ${display(each, depth + 1)}`);
-    return `Map { ${shown(pairs)} }`;
-  }
-  const entries = Object.entries(value).map(([key, each]) => `${key}: ${display(each, depth + 1)}`);
-  return entries.length === 0 ? '{}' : `{ ${shown(entries)} }`;
+function displayElement(element, props) {
+  const shown = Object.entries(props).filter(([name]) => name !== 'children').map(([name, prop]) => ` ${name}=${display(prop)}`);
+  return `<${element}${shown.join('')}>`;
 }
 // an element's edge: text either side of one is not one run of text
 const edge = Symbol('edge');
@@ -437,6 +443,10 @@ function contentSightings(content) {
       sightings.push([...token]);
     }
   }
+  sightings.push(['elements', {
+    roots: selectNodes(content, null),
+    descend: true
+  }]);
   return sightings;
 }
 // fragments, arrays and non-rendered values add no edge: their text runs on into their neighbours'
@@ -519,4 +529,136 @@ function contains(shape, value, arrays) {
 // every prop but children, whose content is walked instead
 function propSightings(props) {
   return Object.entries(props).filter(([name]) => name !== 'children').map(([name, value]) => [`prop:${name}`, value]);
-}
+}
+// an element as a selector reads it; a component, by name, is the parent of what it holds.
+// Each scope is a tree of its own, so a selector sees no ancestor outside it
+var _children = /*#__PURE__*/new WeakMap();
+class SelectElement {
+  constructor(family, name, props, parent, siblings) {
+    _defineProperty(this, "family", void 0);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "props", void 0);
+    _defineProperty(this, "parent", void 0);
+    _defineProperty(this, "siblings", void 0);
+    _classPrivateFieldInitSpec(this, _children, void 0);
+    this.family = family;
+    this.name = name;
+    this.props = props;
+    this.parent = parent;
+    this.siblings = siblings;
+  }
+  get children() {
+    return _classPrivateFieldGet(_children, this) ?? _classPrivateFieldSet(_children, this, selectNodes(this.props.children, this));
+  }
+}
+// fragments and arrays unwrapped, as the page has no node for them
+function selectNodes(content, parent) {
+  const nodes = [];
+  const add = each => {
+    if (ContentNodeIsArray(each)) each.forEach(add);else if (ContentNodeIsLiteral(each)) nodes.push(String(each));else if (!ContentNodeIsElement(each)) return; // null, undefined, boolean
+    else if (ContentNodeElementIsHtml(each)) {
+      nodes.push(new SelectElement('html', each[$type], each[$props], parent, nodes));
+    } else if (ContentNodeElementIsComponent(each)) {
+      const name = componentTypeIdentityKey(each[$type]);
+      nodes.push(new SelectElement('component', name, each[$props], parent, nodes));
+    } else add(each[$props].children);
+  };
+  add(content);
+  return nodes;
+}
+// its own sightings, and itself to match: a children fact in its with list is of its kind.
+// It keeps its place in the tree, so an ancestor in the selector still holds
+const selectOwnSightings = seen => {
+  const element = seen; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+  const {
+    family,
+    name,
+    props
+  } = element;
+  const own = family === 'html' ? htmlOwnSightings(name, props) : componentOwnSightings(name, props);
+  return [...own, ['elements', {
+    roots: [element],
+    descend: false
+  }]];
+};
+function selectSightings(sightings, kind) {
+  const matches = selector(kind.slice('select:'.length));
+  const found = [];
+  const visit = (nodes, descend) => {
+    for (const node of nodes) {
+      if (typeof node === 'string') continue;
+      if (matches(node)) found.push([kind, node]);
+      if (descend) visit(node.children, true);
+    }
+  };
+  for (const [seenKind, value] of sightings) {
+    if (seenKind !== 'elements') continue;
+    const {
+      roots,
+      descend
+    } = value; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+    visit(roots, descend);
+  }
+  return found;
+}
+const selectors = new Map();
+// on the first select(): ~100ms and 44 modules at import, which no other fact needs
+let cssSelect;
+// shipped in the package's vendor/, as dist is
+export const cssSelectBundle = fileURLToPath(new URL('../../vendor/css-select.js', import.meta.url));
+// the vendor bundle (one file, ~9ms), else the package (44 modules, ~100ms)
+function loadCssSelect() {
+  const bundled = existsSync(cssSelectBundle);
+  if (!bundled) {
+    warn(`tungsten ensure: no css-select bundle at ${cssSelectBundle}; ` + 'loading the package instead, which is slower');
+  }
+  const load = createRequire(import.meta.url);
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  return load(bundled ? cssSelectBundle : 'css-select');
+}
+function selector(query) {
+  let compiled = selectors.get(query);
+  if (compiled === undefined) {
+    cssSelect ??= loadCssSelect();
+    // xmlMode: names as written, so Link is a component and link no tag
+    compiled = cssSelect.compile(query, {
+      adapter,
+      xmlMode: true,
+      cacheResults: false
+    });
+    selectors.set(query, compiled);
+  }
+  return compiled;
+}
+// as the page renders it: true present and empty; false, null and undefined absent.
+// class and id only on html, as a component's className is still a prop
+function attribute({
+  family,
+  props
+}, name) {
+  const html = family === 'html';
+  if (name === 'children' || !html && (name === 'class' || name === 'id')) return undefined;
+  const value = !html ? props[name] : name === 'class' ? props.className ?? props.class : name === 'for' ? props.htmlFor ?? props.for : props[name];
+  if (value === undefined || value === null || value === false) return undefined;
+  if (value === true) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number' || typeof value === 'bigint') return String(value);
+  return ''; // a handler or data: present, with no text to compare
+}
+function hasAncestorIn(node, nodes) {
+  for (let up = typeof node === 'string' ? null : node.parent; up !== null; up = up.parent) {
+    if (nodes.includes(up)) return true;
+  }
+  return false;
+}
+const adapter = {
+  isTag: node => typeof node !== 'string',
+  getName: element => element.name,
+  getParent: element => element.parent,
+  getChildren: node => typeof node === 'string' ? [] : node.children,
+  getSiblings: node => typeof node === 'string' ? [node] : node.siblings,
+  getText: node => typeof node === 'string' ? node : contentText(node.props.children),
+  getAttributeValue: attribute,
+  hasAttrib: (element, name) => attribute(element, name) !== undefined,
+  removeSubsets: nodes => nodes.filter((node, i) => nodes.indexOf(node) === i && !hasAncestorIn(node, nodes))
+};

package/dist/testing/host.d.ts

@@ -19,22 +19,18 @@ export type Navigation = {
     to: string;
 };
 export type StateSetter<Component extends TungstenBaseComponent<any, any>> = (state: StateOf<Component>) => StateOf<Component> | void;
-type HostedCore<Component extends TungstenBaseComponent<any, any>> = {
+type HostedCore<Component extends TungstenBaseComponent<any, any>, Content = ContentOf<Component>> = {
     readonly component: Component;
     readonly props: Component['props'];
     readonly state: StateOf<Component>;
     readonly title: string | undefined;
     readonly navigations: readonly Navigation[];
-    content: () => ContentOf<Component>;
-    updateProps: (props: Component['props']) => Promise<Awaited<ContentOf<Component>>>;
-    updateState: (setter: StateSetter<Component>) => Promise<Awaited<ContentOf<Component>>>;
+    content: () => Content;
+    updateProps: (props: Component['props']) => Promise<Awaited<Content>>;
+    updateState: (setter: StateSetter<Component>) => Promise<Awaited<Content>>;
 };
 export type Hosted<Component extends TungstenBaseComponent<any, any>> = HostedCore<Component> & ComponentApi<Component>;
-export type HostedResolved<Component extends TungstenBaseComponent<any, any>> = Omit<HostedCore<Component>, 'content' | 'updateProps' | 'updateState'> & {
-    content: () => Promise<ContentNode>;
-    updateProps: (props: Component['props']) => Promise<ContentNode>;
-    updateState: (setter: StateSetter<Component>) => Promise<ContentNode>;
-} & ComponentApi<Component>;
+export type HostedResolved<Component extends TungstenBaseComponent<any, any>> = HostedCore<Component, Promise<ContentNode>> & ComponentApi<Component>;
 type StoreSchemaOf<Component> = Component extends {
     store: ComponentStore<infer Schema extends object>;
 } ? Schema : never;
@@ -44,7 +40,7 @@ export type HostedRoute = {
     params?: Record<string, string>;
     data?: unknown;
 };
-type RouteOptions = {
+export type RouteOptions = {
     routing: true;
     location: Path;
     routes: Routes<any> | RoutesFunction<any>;
@@ -90,16 +86,16 @@ type StoreOptionsFor<Schema extends object> = {
  * Resolve the content through every component in the tree (the default). false: the hosted
  * component's own content alone, its child components unexpanded.
  */
-type ResolveOption = {
+export type ResolveOption = {
     resolve?: boolean;
 };
-type Resolved = {
+export type Resolve = {
     resolve?: true;
 };
-type Unresolved = {
+export type DontResolve = {
     resolve: false;
 };
-type AppDataOptions = {
+export type AppDataOptions = {
     /** What this.tungsten.context reads. An empty object when not given. */
     context?: object;
     /** What this.tungsten.networkedData reads. An empty object when not given. */
@@ -107,13 +103,17 @@ type AppDataOptions = {
     /** What this.tungsten.globalData reads. An empty object when not given. */
     globalData?: object;
 };
-export type HostStoreOptions<Schema extends object> = (RouteOptions & ResolveOption & AppDataOptions & StoreOptionsFor<Schema>) extends infer Options ? Options extends unknown ? {
+export type HostStoreOptions<Schema extends object, R extends ResolveOption = ResolveOption> = (RouteOptions & R & AppDataOptions & StoreOptionsFor<Schema>) extends infer Options ? Options extends unknown ? {
     [K in keyof Options]: Options[K];
 } : never : never;
-export type HostOptions<Component> = [StoreOf<Component>] extends [never] ? (RouteOptions & ResolveOption & AppDataOptions & (NoStore | StoreOptionsFor<any>)) extends infer Options ? Options extends unknown ? {
+export type HostOptions<Component, R extends ResolveOption = ResolveOption> = [StoreOf<Component>] extends [never] ? (RouteOptions & R & AppDataOptions & (NoStore | StoreOptionsFor<any>)) extends infer Options ? Options extends unknown ? {
     [K in keyof Options]: Options[K];
-} : never : never : HostStoreOptions<StoreOf<Component>>;
-type HostArgs<Props, Component> = [StoreOf<Component>] extends [never] ? object extends Props ? [props?: Props, options?: HostOptions<Component> & Resolved] : [props: Props, options?: HostOptions<Component> & Resolved] : object extends Props ? [props: Props | undefined, options: HostOptions<Component> & Resolved] : [props: Props, options: HostOptions<Component> & Resolved];
+} : never : never : HostStoreOptions<StoreOf<Component>, R>;
+export type HostStoreResolveOptions<Schema extends object> = HostStoreOptions<Schema, Resolve>;
+export type HostStoreDontResolveOptions<Schema extends object> = HostStoreOptions<Schema, DontResolve>;
+export type HostResolveOptions<Component> = HostOptions<Component, Resolve>;
+export type HostDontResolveOptions<Component> = HostOptions<Component, DontResolve>;
+type HostArgs<Props, Component> = [StoreOf<Component>] extends [never] ? object extends Props ? [props?: Props, options?: HostOptions<Component> & Resolve] : [props: Props, options?: HostOptions<Component> & Resolve] : object extends Props ? [props: Props | undefined, options: HostOptions<Component> & Resolve] : [props: Props, options: HostOptions<Component> & Resolve];
 /**
  * Constructs a component outside of any app and drives it the way the framework
  * does - init, then the mount lifecycles - calling its content function with
@@ -139,21 +139,21 @@ export declare function host<Props extends TungstenComponentPropsBase, Schema ex
     store: ComponentStore<Schema>;
 }), props: Props, options: NoInfer<[
     Schema
-] extends [InternalStoreSchema] ? never : HostStoreOptions<Schema> & Unresolved>): Promise<Hosted<Component>>;
-export declare function host<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, props: Props | undefined, options: HostOptions<Component> & Unresolved): Promise<Hosted<Component>>;
+] extends [InternalStoreSchema] ? never : HostStoreOptions<Schema> & DontResolve>): Promise<Hosted<Component>>;
+export declare function host<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, props: Props | undefined, options: HostOptions<Component> & DontResolve): Promise<Hosted<Component>>;
 export declare function host<Props extends TungstenComponentPropsBase, Schema extends object, Component extends TungstenBaseComponent<any, any> & {
     store: ComponentStore<Schema>;
 }>(ComponentType: TungstenComponentClass<Props, Component> & (new (...args: any) => {
     store: ComponentStore<Schema>;
 }), props: Props, options: NoInfer<[
     Schema
-] extends [InternalStoreSchema] ? never : HostStoreOptions<Schema> & Resolved>): Promise<HostedResolved<Component>>;
+] extends [InternalStoreSchema] ? never : HostStoreOptions<Schema> & Resolve>): Promise<HostedResolved<Component>>;
 export declare function host<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, ...[props, options]: HostArgs<Props, Component>): Promise<HostedResolved<Component>>;
 export declare namespace host {
     var generic: typeof hostGeneric;
     var jsx: typeof hostJsx;
 }
-type HostGenericArgs<Component> = [StoreOf<Component>] extends [never] ? [options?: HostOptions<Component> & Resolved] : [options: HostOptions<Component> & Resolved];
+type HostGenericArgs<Component> = [StoreOf<Component>] extends [never] ? [options?: HostOptions<Component> & Resolve] : [options: HostOptions<Component> & Resolve];
 /**
  * host() for a generic component class, whose type arguments it cannot infer: passed as an
  * argument, the class's own parameters are erased to their constraints before the props are
@@ -168,7 +168,7 @@ type HostGenericArgs<Component> = [StoreOf<Component>] extends [never] ? [option
  * one: give it type parameters of its own, or a second call signature, and the inference
  * that makes this work is lost.
  */
-export declare function hostGeneric<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, options: HostOptions<Component> & Unresolved): (props: Props) => Promise<Hosted<Component>>;
+export declare function hostGeneric<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, options: HostOptions<Component> & DontResolve): (props: Props) => Promise<Hosted<Component>>;
 export declare function hostGeneric<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>>(ComponentType: TungstenComponentClass<Props, Component>, ...args: HostGenericArgs<Component>): (props: Props) => Promise<HostedResolved<Component>>;
 type AnyClassComponent = TungstenBaseComponent<any, any>;
 /**
@@ -182,7 +182,7 @@ type AnyClassComponent = TungstenBaseComponent<any, any>;
  * `props`, `state` and the component's own methods. host() itself infers all of that from the
  * class, so a test that leans on the wrapper's api is better off with host().
  */
-export declare function hostJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options: HostOptions<Component> & Unresolved): Promise<Hosted<Component>>;
-export declare function hostJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options?: HostOptions<Component> & Resolved): Promise<HostedResolved<Component>>;
+export declare function hostJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options: HostOptions<Component> & DontResolve): Promise<Hosted<Component>>;
+export declare function hostJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options?: HostOptions<Component> & Resolve): Promise<HostedResolved<Component>>;
 export {};
 //# sourceMappingURL=host.d.ts.map

package/dist/testing/host.js

@@ -45,9 +45,7 @@ async function hostedRouting(options, context, networkedData) {
   return {
     routes: options.routes,
     internalStore: {
-      ...(location !== undefined ? {
-        location
-      } : {}),
+      location: location ?? '/',
       ...(matchedRouteInfo !== undefined ? {
         matchedRouteInfo
       } : {}),

package/dist/testing/hydrateTestApp.js

@@ -147,7 +147,8 @@ export async function hydrateTestApp(RootComponent, ...args) {
   const clientProps = options?.props ?? {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   const serverProps = options?.serverProps ?? clientProps;
   const location = options?.location ?? '/';
-  const globalData = options?.globalData ? options.globalData : {};
+  const globalData = options?.globalData ? options.globalData // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+  : {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   const matchedRouteInfo = {
     key: null,
     params: options?.routeParams ?? {},
@@ -167,9 +168,9 @@ export async function hydrateTestApp(RootComponent, ...args) {
   // routing() falls back to the built-in 404 when neither '404' nor 'default' is given
   // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
   const appRoutes = options?.routes ?? {};
-  const context = options?.context ?? {};
+  const context = options?.context ?? {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   // one object for both passes: the server's is serialized into the page and carried to the client
-  const networkedData = options?.networkedData ?? {};
+  const networkedData = options?.networkedData ?? {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   // dev, so a path given twice fails the test
   const routes = toRoutes(typeof appRoutes === 'function' ? appRoutes(null, context, networkedData) : appRoutes, true);
   // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- rootToHtml.ts builds a root content node the same way

package/dist/testing/index.d.ts

@@ -1,12 +1,11 @@
 export { loadEnv } from './loadEnv.js';
 export { testEnvVariableName } from './testEnvIsRequested.js';
 export { type HydrateTestApp, type HydrateTestAppOptions, hydrateTestApp, } from './hydrateTestApp.js';
-export { type HydrateTestPipelineApp, type HydrateTestPipelineAppOptions, hydrateTestPipelineApp, } from './hydrateTestPipelineApp.js';
 export { type ComponentProps, type CreateTestAppArgs, type TestApp, type TestAppOptions, type TestStore, type TestStoreOverride, type TestStoreRegistration, type TestRoutes, createTestApp, testStore, } from './createTestApp.js';
-export { type CreateTestPipelineAppArgs, type TestPipelineApp, type TestPipelineAppOptions, createTestPipelineApp, } from './createTestPipelineApp.js';
-export { type HostOptions, type HostStoreOptions, type Hosted, type HostedResolved, host, hostGeneric, hostJsx, } from './host.js';
+export { type HostDontResolveOptions, type HostOptions, type HostResolveOptions, type HostStoreDontResolveOptions, type HostStoreOptions, type HostStoreResolveOptions, type Hosted, type HostedResolved, host, hostGeneric, hostJsx, } from './host.js';
 export { testingComponentPackage } from './testingComponentPackage.js';
 export { contentHtmlElements } from './helpers/contentHtmlElements.js';
 export { ensure } from './ensure.js';
+export { contentToString, type ContentToStringOptions } from './contentToString.js';
 export { makeStore, type TrueStore } from '../Store/makeStore.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/testing/index.js

@@ -1,11 +1,10 @@
 export { loadEnv } from './loadEnv.js';
 export { testEnvVariableName } from './testEnvIsRequested.js';
 export { hydrateTestApp } from './hydrateTestApp.js';
-export { hydrateTestPipelineApp } from './hydrateTestPipelineApp.js';
 export { createTestApp, testStore } from './createTestApp.js';
-export { createTestPipelineApp } from './createTestPipelineApp.js';
 export { host, hostGeneric, hostJsx } from './host.js';
 export { testingComponentPackage } from './testingComponentPackage.js';
 export { contentHtmlElements } from './helpers/contentHtmlElements.js';
 export { ensure } from './ensure.js';
+export { contentToString } from './contentToString.js';
 export { makeStore } from '../Store/makeStore.js';

package/dist/testing/pipeline/createTestPacketApp.d.ts

@@ -0,0 +1,30 @@
+import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../../Components.jsx';
+import type { Nothing } from '../../pipeline/pipeline.js';
+import type { TestApp } from '../createTestApp.js';
+import type { PipelineTestAppOptions } from './pipelineTestApp.js';
+type Field<K extends string, T, Default> = Default extends T ? {
+    [_ in K]?: T;
+} : {
+    [_ in K]: T;
+};
+export type PacketForComponent<C> = C extends {
+    readonly tungsten: {
+        readonly context: infer Ctx;
+        readonly networked: infer N;
+        readonly allRoutesData: infer G;
+    };
+} ? Field<'context', Ctx, Nothing> & Field<'networked', N, Nothing> & Field<'allRoutesData', G, undefined> & {
+    routes?: never;
+} : 'invalid component';
+export type TestPacketAppOptions<Props extends object> = PipelineTestAppOptions<Props>;
+export type CreateTestPacketAppArgs<Props extends object> = object extends Props ? [options?: TestPacketAppOptions<Props>] : [options: TestPacketAppOptions<Props> & {
+    props: Props;
+}];
+/**
+ * createTestPipelineApp() with the pipeline's result in place of the pipeline: the component is
+ * handed the packet's context, networked data and all-routes data as they are, with no stages run.
+ * There are no routes; the location still reaches the instance.
+ */
+export declare function createTestPacketApp<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, RouteData = undefined>(packet: PacketForComponent<Component>, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: CreateTestPacketAppArgs<Props>): Promise<TestApp<Component>>;
+export {};
+//# sourceMappingURL=createTestPacketApp.d.ts.map