gesso-framework 0.1.0

package/dist/createComponent-3n1ZSql8.js

@@ -0,0 +1,254 @@
+import { defer, distinctUntilChanged, map, of } from "rxjs";
+import { isComponentLikeElement, isObservable } from "gesso-core";
+//#region src/each.ts
+/**
+* A keyed list.
+*
+*   <Each of={rows} by="id">{row => <Row row={row} />}</Each>
+*
+* The `map`, the change check and the keying, which every screen in
+* both applications wrote by hand: forty blocks of
+* `map(items => items.map(item => <Row key={item.id} />))`, each of
+* which rebuilt every row's element on every emission of the list.
+*
+* A row's element is built once and kept while the row is in the list
+* and its value has not changed, so a list that re-emits equal data
+* builds nothing and reconciles nothing: the result is the same array,
+* and the change check downstream ends the emission there. A row whose
+* value changed is rebuilt alone; the key keeps its node and its
+* component instance, so only what changed is written.
+*
+* `key` is set from `by` on the element the function returns, so a row
+* component is written without one. An element that carries its own key
+* keeps it.
+*
+* `LazyColumn` is the same shape for a list long enough that only the
+* visible rows should exist. This is the short-list case, and the two
+* read alike on purpose.
+*/
+function Each(props) {
+	return each(props.of, props.by, props.children);
+}
+/**
+* The function form of `Each`, for a list built outside a tag:
+*
+*   const rows = each(tracks, 'id', track => <ItemRow item={track} />);
+*/
+function each(source, by, render) {
+	const keyOf = keyFunction(by);
+	const dynamic = isObservable(source);
+	const items = dynamic ? source : of(source);
+	if (by === void 0 && dynamic) warnIndexKeyed(render);
+	const positional = render.length >= 2;
+	return defer(() => {
+		const held = /* @__PURE__ */ new Map();
+		let previous = null;
+		let generation = 0;
+		return items.pipe(map((list) => {
+			previous = reconcile(held, previous, ++generation, list, keyOf, render, positional);
+			return previous;
+		}), distinctUntilChanged());
+	});
+}
+/**
+* Builds the children for one emission, reusing every row it can.
+*
+* The result is the previous array itself when nothing about the list
+* changed, so the `distinctUntilChanged` above it ends the emission and
+* the builder is never entered. A new array is allocated at the first
+* row that differs and not before, which is what keeps an unchanged
+* emission free rather than merely cheap.
+*/
+function reconcile(held, previous, generation, list, keyOf, render, positional) {
+	let next = null;
+	for (let index = 0; index < list.length; index++) {
+		const item = list[index];
+		const key = keyOf(item, index);
+		const row = held.get(key);
+		if (row !== void 0 && row.generation === generation) throw new Error(`Duplicate key '${String(key)}' in a list: two rows claim the same identity.`);
+		let child;
+		if (row !== void 0 && Object.is(row.item, item) && (!positional || row.index === index)) {
+			child = row.child;
+			row.index = index;
+			row.generation = generation;
+		} else {
+			child = keyed$1(render(item, index), key);
+			if (row === void 0) held.set(key, {
+				item,
+				index,
+				child,
+				generation
+			});
+			else {
+				row.item = item;
+				row.index = index;
+				row.child = child;
+				row.generation = generation;
+			}
+		}
+		if (next === null && (previous === null || index >= previous.length || previous[index] !== child)) next = previous === null ? [] : previous.slice(0, index);
+		next?.push(child);
+	}
+	for (const [key, row] of held) if (row.generation !== generation) held.delete(key);
+	if (next === null && previous !== null && previous.length !== list.length) next = previous.slice(0, list.length);
+	return next ?? previous ?? EMPTY$2;
+}
+const EMPTY$2 = [];
+function keyFunction(by) {
+	if (by === void 0) return (_item, index) => index;
+	if (typeof by === "function") return by;
+	return (item) => item[by];
+}
+/**
+* Puts the row's key on the element the render function returned.
+*
+* An element that named its own key keeps it, since the author meant
+* something by it. An observable row cannot carry one at all: its
+* fragment anchor is identified by position, so a list of them
+* reorders wrongly, and it is worth saying so rather than leaving a
+* reorder to look like corruption.
+*/
+function keyed$1(child, key) {
+	if (isComponentLikeElement(child)) return child.key === void 0 || child.key === null ? {
+		...child,
+		key
+	} : child;
+	if (isObservable(child)) throw new Error(`A row of a list is an observable, which cannot carry the key '${String(key)}'. Return an element or a component from the row function and bind the observable inside it.`);
+	const element = child;
+	const existing = element.props.key;
+	if (existing !== void 0 && existing !== null) return element;
+	return {
+		...element,
+		props: {
+			...element.props,
+			key
+		}
+	};
+}
+/** Said once: every unkeyed list has the same problem and the same fix. */
+let warnedAboutIndexKeys = false;
+function warnIndexKeyed(render) {
+	if (warnedAboutIndexKeys) return;
+	warnedAboutIndexKeys = true;
+	const what = render.name === "" ? "a list" : `the list drawn by '${render.name}'`;
+	console.warn(`${what} is keyed by index, because \`each\` was given no \`by\`. A row inserted or removed anywhere but the end then shifts every row after it onto a different node: state moves between rows, a text field keeps the wrong value, and an animation runs on the wrong element. Pass \`by\` naming what identifies a row: by="id", or by={row => row.id}.`);
+}
+//#endregion
+//#region src/show.ts
+/**
+* One child, while a condition holds.
+*
+*   <Show when={liked}>{() => <Icon path={ICONS.heart} />}</Show>
+*
+* `{cond && <x />}` already works when `cond` is a plain value, because
+* JSX drops a `false` child. A reactive `cond` had to become
+* `cond.pipe(map(on => (on ? [<x key="x" />] : [])))`, which is the
+* fifty-six-block idiom in the two applications, and the discontinuity
+* between the two forms is the surprise this removes.
+*
+* The child is built once, on the first frame it is shown, and kept
+* while it is shown: a condition that emits `true` again draws nothing
+* and reconciles nothing. It carries a stable key, so the node it
+* built is the node it gets back when the condition returns, and it
+* adds no node of its own: what a `Show` puts under its parent is the
+* child, or nothing, and never a wrapper that layout would have to
+* account for.
+*
+* Anything inside it that changes is bound as usual. The function is
+* not re-run when the *data* changes, only when the condition does, so
+* a `Show` whose child shows a value binds that value rather than
+* reading it.
+*/
+function Show(props) {
+	return show(props.when, props.children, props.otherwise);
+}
+/**
+* The function form of `Show`:
+*
+*   {show(liked, () => <Icon path={ICONS.heart} />)}
+*/
+function show(when, children, otherwise) {
+	const condition = isObservable(when) ? when : of(when);
+	return defer(() => {
+		let shown = null;
+		let hidden = null;
+		return condition.pipe(map((value) => Boolean(value)), distinctUntilChanged(), map((on) => {
+			if (on) {
+				shown ??= [keyed(children(), "when")];
+				return shown;
+			}
+			hidden ??= otherwise === void 0 ? EMPTY$1 : [keyed(otherwise(), "otherwise")];
+			return hidden;
+		}));
+	});
+}
+const EMPTY$1 = [];
+/**
+* Gives the branch its stable key, so returning to it returns to the
+* node it built. An element that named its own key keeps it.
+*/
+function keyed(child, key) {
+	if (isComponentLikeElement(child)) return child.key === void 0 || child.key === null ? {
+		...child,
+		key
+	} : child;
+	if (isObservable(child)) return child;
+	const element = child;
+	const existing = element.props.key;
+	if (existing !== void 0 && existing !== null) return element;
+	return {
+		...element,
+		props: {
+			...element.props,
+			key
+		}
+	};
+}
+//#endregion
+//#region src/metadata.ts
+const metadataStore = /* @__PURE__ */ new WeakMap();
+function getComponentMetadata(constructor) {
+	let metadata = metadataStore.get(constructor);
+	if (metadata === void 0) {
+		metadata = {
+			tag: constructor.name,
+			inputs: /* @__PURE__ */ new Set(),
+			states: /* @__PURE__ */ new Set(),
+			injects: /* @__PURE__ */ new Map(),
+			channels: /* @__PURE__ */ new Map()
+		};
+		metadataStore.set(constructor, metadata);
+	}
+	return metadata;
+}
+//#endregion
+//#region src/createComponent.ts
+/**
+* Creates a ComponentElement for use as a child of a UiElement.
+*
+*   Column(
+*     createComponent(Counter, { label: 'Count' }),
+*     createComponent(TodoItem, { todo }, todo.id)
+*   )
+*
+* The component may be a class extending Component or a function
+* `(props, ctx) => UiChild`. Props are typed from the component: a
+* class's `input()` fields, or a function's `Inputs<P>` parameter. A
+* misspelled prop, a value of the wrong type, and a missing required
+* prop are compile errors; props may be omitted only when none is
+* required.
+*/
+function createComponent(component, ...args) {
+	const [props, key] = args;
+	return {
+		kind: "component",
+		tag: getComponentMetadata(component).tag,
+		component,
+		props: props ?? {},
+		key
+	};
+}
+//#endregion
+export { Each as a, show as i, getComponentMetadata as n, each as o, Show as r, createComponent as t };
+
+//# sourceMappingURL=createComponent-3n1ZSql8.js.map

package/dist/createComponent-3n1ZSql8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createComponent-3n1ZSql8.js","names":["keyed","EMPTY","EMPTY"],"sources":["../src/each.ts","../src/show.ts","../src/metadata.ts","../src/createComponent.ts"],"sourcesContent":["import { Observable, defer, distinctUntilChanged, map, of } from 'rxjs';\n\nimport { isComponentLikeElement, isObservable, type UiChild, type UiElement } from 'gesso-core';\n\n/**\n * What gives a row its identity: the name of a field holding it, or a\n * function returning it. Omitting it keys by index, which is what the\n * builder falls back to and what `each` warns about.\n */\nexport type EachKey<T> = (keyof T & string) | ((item: T, index: number) => string | number);\n\nexport interface EachProps<T> {\n  /** The list: a cell, any Observable of one, or a plain array. */\n  readonly of: Observable<readonly T[]> | readonly T[];\n  /** Identity per row. See `EachKey`. */\n  readonly by?: EachKey<T>;\n  /** What one row draws as. */\n  readonly children: (item: T, index: number) => UiChild;\n}\n\n/**\n * A keyed list.\n *\n *   <Each of={rows} by=\"id\">{row => <Row row={row} />}</Each>\n *\n * The `map`, the change check and the keying, which every screen in\n * both applications wrote by hand: forty blocks of\n * `map(items => items.map(item => <Row key={item.id} />))`, each of\n * which rebuilt every row's element on every emission of the list.\n *\n * A row's element is built once and kept while the row is in the list\n * and its value has not changed, so a list that re-emits equal data\n * builds nothing and reconciles nothing: the result is the same array,\n * and the change check downstream ends the emission there. A row whose\n * value changed is rebuilt alone; the key keeps its node and its\n * component instance, so only what changed is written.\n *\n * `key` is set from `by` on the element the function returns, so a row\n * component is written without one. An element that carries its own key\n * keeps it.\n *\n * `LazyColumn` is the same shape for a list long enough that only the\n * visible rows should exist. This is the short-list case, and the two\n * read alike on purpose.\n */\nexport function Each<T>(props: EachProps<T>): Observable<readonly UiChild[]> {\n  return each(props.of, props.by, props.children);\n}\n\n/**\n * The function form of `Each`, for a list built outside a tag:\n *\n *   const rows = each(tracks, 'id', track => <ItemRow item={track} />);\n */\nexport function each<T>(\n  source: Observable<readonly T[]> | readonly T[],\n  by: EachKey<T> | undefined,\n  render: (item: T, index: number) => UiChild\n): Observable<readonly UiChild[]> {\n  const keyOf = keyFunction(by);\n  const dynamic = isObservable(source);\n  const items = dynamic ? (source as Observable<readonly T[]>) : of(source as readonly T[]);\n  if (by === undefined && dynamic) {\n    warnIndexKeyed(render);\n  }\n  // Whether the row function took the index. One that did not is\n  // unaffected by its row moving, so a reorder or a removal reuses\n  // every element it already built; one that did has to be asked again\n  // for a row that moved, since the index is part of what it drew.\n  const positional = render.length >= 2;\n  return defer(() => {\n    const held = new Map<string | number, Row<T>>();\n    let previous: readonly UiChild[] | null = null;\n    let generation = 0;\n    return items.pipe(\n      map(list => {\n        previous = reconcile(held, previous, ++generation, list, keyOf, render, positional);\n        return previous;\n      }),\n      distinctUntilChanged()\n    );\n  });\n}\n\n/** One row's element, and what it was built from. */\ninterface Row<T> {\n  item: T;\n  index: number;\n  child: UiChild;\n  /** The pass that last saw this key; anything older has left the list. */\n  generation: number;\n}\n\n/**\n * Builds the children for one emission, reusing every row it can.\n *\n * The result is the previous array itself when nothing about the list\n * changed, so the `distinctUntilChanged` above it ends the emission and\n * the builder is never entered. A new array is allocated at the first\n * row that differs and not before, which is what keeps an unchanged\n * emission free rather than merely cheap.\n */\nfunction reconcile<T>(\n  held: Map<string | number, Row<T>>,\n  previous: readonly UiChild[] | null,\n  generation: number,\n  list: readonly T[],\n  keyOf: (item: T, index: number) => string | number,\n  render: (item: T, index: number) => UiChild,\n  positional: boolean\n): readonly UiChild[] {\n  let next: UiChild[] | null = null;\n  for (let index = 0; index < list.length; index++) {\n    const item = list[index] as T;\n    const key = keyOf(item, index);\n    const row = held.get(key);\n    if (row !== undefined && row.generation === generation) {\n      throw new Error(`Duplicate key '${String(key)}' in a list: two rows claim the same identity.`);\n    }\n    let child: UiChild;\n    if (row !== undefined && Object.is(row.item, item) && (!positional || row.index === index)) {\n      child = row.child;\n      row.index = index;\n      row.generation = generation;\n    } else {\n      child = keyed(render(item, index), key);\n      if (row === undefined) {\n        held.set(key, { item, index, child, generation });\n      } else {\n        row.item = item;\n        row.index = index;\n        row.child = child;\n        row.generation = generation;\n      }\n    }\n    if (next === null && (previous === null || index >= previous.length || previous[index] !== child)) {\n      next = previous === null ? [] : previous.slice(0, index);\n    }\n    next?.push(child);\n  }\n  for (const [key, row] of held) {\n    if (row.generation !== generation) {\n      held.delete(key);\n    }\n  }\n  if (next === null && previous !== null && previous.length !== list.length) {\n    // Nothing before the end changed and the list got shorter: the\n    // rows that remain are the ones already in `previous`.\n    next = previous.slice(0, list.length);\n  }\n  return next ?? previous ?? EMPTY;\n}\n\nconst EMPTY: readonly UiChild[] = [];\n\nfunction keyFunction<T>(by: EachKey<T> | undefined): (item: T, index: number) => string | number {\n  if (by === undefined) {\n    return (_item, index) => index;\n  }\n  if (typeof by === 'function') {\n    return by;\n  }\n  return item => (item as Record<string, unknown>)[by] as string | number;\n}\n\n/**\n * Puts the row's key on the element the render function returned.\n *\n * An element that named its own key keeps it, since the author meant\n * something by it. An observable row cannot carry one at all: its\n * fragment anchor is identified by position, so a list of them\n * reorders wrongly, and it is worth saying so rather than leaving a\n * reorder to look like corruption.\n */\nfunction keyed(child: UiChild, key: string | number): UiChild {\n  if (isComponentLikeElement(child)) {\n    return child.key === undefined || child.key === null ? { ...child, key } : child;\n  }\n  if (isObservable(child)) {\n    throw new Error(\n      `A row of a list is an observable, which cannot carry the key '${String(key)}'. ` +\n        `Return an element or a component from the row function and bind the observable inside it.`\n    );\n  }\n  const element = child as UiElement;\n  const existing = element.props.key;\n  if (existing !== undefined && existing !== null) {\n    return element;\n  }\n  return { ...element, props: { ...element.props, key } };\n}\n\n/** Said once: every unkeyed list has the same problem and the same fix. */\nlet warnedAboutIndexKeys = false;\n\nfunction warnIndexKeyed(render: (item: never, index: number) => UiChild): void {\n  if (warnedAboutIndexKeys) {\n    return;\n  }\n  warnedAboutIndexKeys = true;\n  const what = render.name === '' ? 'a list' : `the list drawn by '${render.name}'`;\n  console.warn(\n    `${what} is keyed by index, because \\`each\\` was given no \\`by\\`. A row inserted or removed ` +\n      `anywhere but the end then shifts every row after it onto a different node: state moves between rows, ` +\n      `a text field keeps the wrong value, and an animation runs on the wrong element. ` +\n      `Pass \\`by\\` naming what identifies a row: by=\"id\", or by={row => row.id}.`\n  );\n}\n","import { Observable, defer, distinctUntilChanged, map, of } from 'rxjs';\n\nimport { isComponentLikeElement, isObservable, type UiChild, type UiElement } from 'gesso-core';\n\nexport interface ShowProps {\n  /** The condition: a cell, any Observable, or a plain value. */\n  readonly when: Observable<unknown> | unknown;\n  /** What to draw while it is truthy. */\n  readonly children: () => UiChild;\n  /** What to draw while it is not. Nothing, by default. */\n  readonly otherwise?: () => UiChild;\n}\n\n/**\n * One child, while a condition holds.\n *\n *   <Show when={liked}>{() => <Icon path={ICONS.heart} />}</Show>\n *\n * `{cond && <x />}` already works when `cond` is a plain value, because\n * JSX drops a `false` child. A reactive `cond` had to become\n * `cond.pipe(map(on => (on ? [<x key=\"x\" />] : [])))`, which is the\n * fifty-six-block idiom in the two applications, and the discontinuity\n * between the two forms is the surprise this removes.\n *\n * The child is built once, on the first frame it is shown, and kept\n * while it is shown: a condition that emits `true` again draws nothing\n * and reconciles nothing. It carries a stable key, so the node it\n * built is the node it gets back when the condition returns, and it\n * adds no node of its own: what a `Show` puts under its parent is the\n * child, or nothing, and never a wrapper that layout would have to\n * account for.\n *\n * Anything inside it that changes is bound as usual. The function is\n * not re-run when the *data* changes, only when the condition does, so\n * a `Show` whose child shows a value binds that value rather than\n * reading it.\n */\nexport function Show(props: ShowProps): Observable<readonly UiChild[]> {\n  return show(props.when, props.children, props.otherwise);\n}\n\n/**\n * The function form of `Show`:\n *\n *   {show(liked, () => <Icon path={ICONS.heart} />)}\n */\nexport function show(\n  when: Observable<unknown> | unknown,\n  children: () => UiChild,\n  otherwise?: () => UiChild\n): Observable<readonly UiChild[]> {\n  const condition = isObservable(when) ? (when as Observable<unknown>) : of(when);\n  return defer(() => {\n    let shown: readonly UiChild[] | null = null;\n    let hidden: readonly UiChild[] | null = null;\n    return condition.pipe(\n      map(value => Boolean(value)),\n      distinctUntilChanged(),\n      map(on => {\n        if (on) {\n          shown ??= [keyed(children(), 'when')];\n          return shown;\n        }\n        hidden ??= otherwise === undefined ? EMPTY : [keyed(otherwise(), 'otherwise')];\n        return hidden;\n      })\n    );\n  });\n}\n\nconst EMPTY: readonly UiChild[] = [];\n\n/**\n * Gives the branch its stable key, so returning to it returns to the\n * node it built. An element that named its own key keeps it.\n */\nfunction keyed(child: UiChild, key: string): UiChild {\n  if (isComponentLikeElement(child)) {\n    return child.key === undefined || child.key === null ? { ...child, key } : child;\n  }\n  if (isObservable(child)) {\n    return child;\n  }\n  const element = child as UiElement;\n  const existing = element.props.key;\n  if (existing !== undefined && existing !== null) {\n    return element;\n  }\n  return { ...element, props: { ...element.props, key } };\n}\n","export const COMPONENT_METADATA_KEY = Symbol('gesso:component:metadata');\n\nexport interface ComponentMetadata {\n  tag: string;\n  inputs: Set<string>;\n  states: Set<string>;\n  injects: Map<string, Function>;\n  /** Property name → the channel token it resolves to (`@Channel`). */\n  channels: Map<string, { name: string }>;\n}\n\nconst metadataStore = new WeakMap<Function, ComponentMetadata>();\n\nexport function getComponentMetadata(constructor: Function): ComponentMetadata {\n  let metadata = metadataStore.get(constructor);\n  if (metadata === undefined) {\n    metadata = { tag: constructor.name, inputs: new Set(), states: new Set(), injects: new Map(), channels: new Map() };\n    metadataStore.set(constructor, metadata);\n  }\n  return metadata;\n}\n\nexport function hasComponentMetadata(constructor: Function): boolean {\n  return metadataStore.has(constructor);\n}\n","import type { ComponentElement } from './ComponentElement';\nimport type { ComponentArgs, ComponentProps, ComponentType } from './FunctionComponent';\nimport { getComponentMetadata } from './metadata';\n\n/**\n * Creates a ComponentElement for use as a child of a UiElement.\n *\n *   Column(\n *     createComponent(Counter, { label: 'Count' }),\n *     createComponent(TodoItem, { todo }, todo.id)\n *   )\n *\n * The component may be a class extending Component or a function\n * `(props, ctx) => UiChild`. Props are typed from the component: a\n * class's `input()` fields, or a function's `Inputs<P>` parameter. A\n * misspelled prop, a value of the wrong type, and a missing required\n * prop are compile errors; props may be omitted only when none is\n * required.\n */\nexport function createComponent<C extends ComponentType>(\n  component: C,\n  ...args: ComponentArgs<C>\n): ComponentElement<ComponentProps<C>> {\n  const [props, key] = args as [ComponentProps<C> | undefined, string | number | undefined];\n  const metadata = getComponentMetadata(component);\n  return {\n    kind: 'component',\n    tag: metadata.tag,\n    component,\n    props: (props ?? {}) as ComponentProps<C>,\n    key\n  };\n}\n"],"mappings":"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"}