@tschk/moonshine-dom 0.0.0-stage → 0.4.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,176 @@
1
+ import { cleanupOrderKey } from "./cleanup-order";
2
+ /** Native component ownership/context ABI; no source-language compiler runtime. */
3
+ import {
4
+ cleanupComputationKey,
5
+ createComponentScope,
6
+ getOwner,
7
+ getRenderScheduler,
8
+ type Owner,
9
+ } from "./reactive";
10
+
11
+ const componentKey = /* @__PURE__ */ Symbol("moonshine.component");
12
+ const contextSourceKey = /* @__PURE__ */ Symbol(
13
+ "moonshine.component.contextSource",
14
+ );
15
+ type ComponentContextSource = ComponentContext & {
16
+ readonly [contextSourceKey]?: ReadonlyMap<unknown, unknown>;
17
+ };
18
+ /** Explicit per-instance event listener map; interpreted by compiler adapters. */
19
+ export const componentEvents = /* @__PURE__ */ Symbol(
20
+ "moonshine.component.events",
21
+ );
22
+ export interface ComponentContext<P = unknown> {
23
+ readonly props: P;
24
+ readonly owner: Owner;
25
+ readonly mode: "dom" | "ssr";
26
+ readonly contexts: ReadonlyMap<unknown, unknown>;
27
+ active: boolean;
28
+ ready?: Array<() => void>;
29
+ capture?: (instance: object) => void;
30
+ }
31
+ export function peekComponentContext(): ComponentContext | undefined {
32
+ return getOwner()?.context?.get(componentKey) as ComponentContext | undefined;
33
+ }
34
+ export function getComponentContext(): ComponentContext {
35
+ const frame = peekComponentContext();
36
+ const owner = getOwner();
37
+ if (
38
+ !frame?.active ||
39
+ !owner ||
40
+ (owner.disposed && !owner.context?.has(cleanupComputationKey))
41
+ )
42
+ throw new Error(
43
+ "Component context is available only during native component initialization",
44
+ );
45
+ return frame;
46
+ }
47
+ export interface ComponentInvocation {
48
+ contexts?: ReadonlyMap<unknown, unknown>;
49
+ capture?: (instance: object) => void;
50
+ }
51
+ export function createComponent<P, T>(
52
+ fn: (props: P) => T,
53
+ props: P,
54
+ mode: "dom" | "ssr",
55
+ options?: ComponentInvocation,
56
+ ): T {
57
+ const inherited = peekComponentContext() as
58
+ ComponentContextSource | undefined;
59
+ return createComponentScope(() => {
60
+ const owner = getOwner()!;
61
+ let captured = false;
62
+ let contexts: Map<unknown, unknown> | undefined;
63
+ const frame: ComponentContext<P> & ComponentContextSource = {
64
+ props,
65
+ owner,
66
+ mode,
67
+ // Skip untouched ancestors without initializing their context maps.
68
+ get [contextSourceKey]() {
69
+ return (
70
+ contexts ??
71
+ options?.contexts ??
72
+ (inherited &&
73
+ (contextSourceKey in inherited
74
+ ? inherited[contextSourceKey]
75
+ : inherited.contexts))
76
+ );
77
+ },
78
+ get contexts() {
79
+ return (contexts ??= new Map(frame[contextSourceKey]));
80
+ },
81
+ active: true,
82
+ };
83
+ if (options?.capture)
84
+ frame.capture = (instance) => {
85
+ captured = true;
86
+ options.capture!(instance);
87
+ };
88
+ owner.context = new Map(owner.context);
89
+ // Native component frames start their own default cleanup policy.
90
+ owner.context.delete(cleanupOrderKey);
91
+ owner.context.set(componentKey, frame);
92
+ let result: T;
93
+ try {
94
+ const scheduler = getRenderScheduler();
95
+ result = scheduler ? scheduler.component(() => fn(props)) : fn(props);
96
+ } finally {
97
+ frame.active = false;
98
+ }
99
+ if (!captured && !owner.disposed) options?.capture?.(Object.create(null));
100
+ const ready = frame.ready?.splice(0);
101
+ if (ready && !owner.disposed) {
102
+ let failed = false;
103
+ let failure: unknown;
104
+ for (const callback of ready) {
105
+ if (owner.disposed) break;
106
+ try {
107
+ callback();
108
+ } catch (error) {
109
+ if (!failed) failure = error;
110
+ failed = true;
111
+ }
112
+ }
113
+ if (failed) throw failure;
114
+ }
115
+ return result;
116
+ });
117
+ }
118
+ /** Internal setup completion, before the enclosing component scope returns. */
119
+ export function onComponentReady(fn: () => void): void {
120
+ (getComponentContext().ready ??= []).push(fn);
121
+ }
122
+
123
+ export function getContext<T>(key: unknown): T | undefined {
124
+ return getComponentContext().contexts.get(key) as T | undefined;
125
+ }
126
+ export function setContext<T>(key: unknown, value: T): T {
127
+ (getComponentContext().contexts as Map<unknown, unknown>).set(key, value);
128
+ return value;
129
+ }
130
+ export function hasContext(key: unknown): boolean {
131
+ return getComponentContext().contexts.has(key);
132
+ }
133
+ /** Snapshot: callers cannot mutate an inactive component's context through it. */
134
+ export function getAllContexts(): Map<unknown, unknown> {
135
+ return new Map(getComponentContext().contexts);
136
+ }
137
+
138
+ /** Internal compiler adapter boundary: retain the invocation owner/attempt. */
139
+ export function withComponentConsumer<T>(
140
+ frame: ComponentContext,
141
+ fn: () => T,
142
+ ): T {
143
+ return withConsumer(frame, fn, false);
144
+ }
145
+ /** Internal historical computation boundary; current owner stays disposed if already stopped. */
146
+ export function withComponentCleanupConsumer<T>(
147
+ frame: ComponentContext,
148
+ fn: () => T,
149
+ ): T {
150
+ return withConsumer(frame, fn, true);
151
+ }
152
+ function withConsumer<T>(
153
+ frame: ComponentContext,
154
+ fn: () => T,
155
+ cleanup: boolean,
156
+ ): T {
157
+ const owner = getOwner();
158
+ if (!owner || (!cleanup && (owner.disposed || frame.owner.disposed)))
159
+ throw new Error("Live component consumer required");
160
+ const context = owner.context,
161
+ active = frame.active,
162
+ wasDisposed = owner.disposed;
163
+ owner.context = new Map(context);
164
+ owner.context.set(componentKey, frame);
165
+ if (cleanup) owner.context.set(cleanupComputationKey, true);
166
+ frame.active = true;
167
+ try {
168
+ return fn();
169
+ } finally {
170
+ frame.active = active;
171
+ owner.context =
172
+ owner.disposed && !wasDisposed && !context?.has(cleanupComputationKey)
173
+ ? undefined
174
+ : context;
175
+ }
176
+ }
package/src/control.ts ADDED
@@ -0,0 +1,367 @@
1
+ /** Owned control flow for Moonshine lowering, not Solid's compiled ABI. */
2
+ import {
3
+ batch,
4
+ createMemo,
5
+ createRenderMemo,
6
+ getRenderScheduler,
7
+ getOwner,
8
+ type Owner,
9
+ createRoot,
10
+ createComponentScope,
11
+ createSignal,
12
+ onCleanup,
13
+ type Accessor,
14
+ type Setter,
15
+ } from "./reactive";
16
+
17
+ type Entry<T, U> = {
18
+ item: T;
19
+ value: U;
20
+ index: Setter<number>;
21
+ dispose: () => void;
22
+ scope?: Owner;
23
+ };
24
+
25
+ function owned<T>(
26
+ fn: () => T,
27
+ order?: () => number,
28
+ owner?: Owner | null,
29
+ ): { value: T; dispose: () => void; scope?: Owner } {
30
+ let stop: (() => void) | undefined;
31
+ try {
32
+ return createRoot((dispose) => {
33
+ stop = dispose;
34
+ const scheduler = getRenderScheduler();
35
+ const value = scheduler ? scheduler.branch(fn, order) : fn();
36
+ if (owner && !owner.disposed) {
37
+ const scope = getOwner()!;
38
+ scope.parent = owner;
39
+ owner.children.add(scope);
40
+ }
41
+ return owner
42
+ ? { value, dispose, scope: getOwner()! }
43
+ : { value, dispose };
44
+ });
45
+ } catch (error) {
46
+ try {
47
+ stop?.();
48
+ } catch {
49
+ // Preserve the mapper failure after all owned cleanups run.
50
+ }
51
+ throw error;
52
+ }
53
+ }
54
+
55
+ function disposeAll(entries: Iterable<{ dispose: () => void }>): void {
56
+ let failed = false;
57
+ let failure: unknown;
58
+ for (const entry of entries) {
59
+ try {
60
+ entry.dispose();
61
+ } catch (error) {
62
+ if (!failed) failure = error;
63
+ failed = true;
64
+ }
65
+ }
66
+ if (failed) throw failure;
67
+ }
68
+
69
+ /** Optional deferRemoved takes ownership of removed roots; throwing falls back to disposal. */
70
+ export function mapArray<T, U>(
71
+ list: Accessor<readonly T[]>,
72
+ map: (item: T, index: Accessor<number>) => U,
73
+ deferRemoved?: (dispose: () => void) => void,
74
+ schedule: (read: () => U[]) => Accessor<U[]> = createRenderMemo,
75
+ ): Accessor<U[]> {
76
+ const owner = getRenderScheduler()
77
+ ? createComponentScope(() => getOwner()!)
78
+ : undefined;
79
+ let entries: Entry<T, U>[] = [];
80
+ let disposed = false;
81
+ onCleanup(() => {
82
+ disposed = true;
83
+ const previous = entries;
84
+ entries = [];
85
+ disposeAll(previous);
86
+ });
87
+ return schedule(() => {
88
+ const items = list();
89
+ const available = new Map<T, Entry<T, U>[]>();
90
+ for (let i = entries.length - 1; i >= 0; i--) {
91
+ const entry = entries[i]!;
92
+ const bucket = available.get(entry.item);
93
+ if (bucket) bucket.push(entry);
94
+ else available.set(entry.item, [entry]);
95
+ }
96
+ const created: Entry<T, U>[] = [];
97
+ let next: Entry<T, U>[];
98
+ try {
99
+ next = [];
100
+ for (let position = 0; position < items.length; position++) {
101
+ if (disposed) break;
102
+ const item = items[position]!;
103
+ const retained = available.get(item)?.pop();
104
+ if (retained) {
105
+ next.push(retained);
106
+ continue;
107
+ }
108
+ const [index, setIndex] = createSignal(position);
109
+ const root = owned(() => map(item, index), index, owner);
110
+ const entry = { item, ...root, index: setIndex };
111
+ created.push(entry);
112
+ next.push(entry);
113
+ }
114
+ } catch (error) {
115
+ try {
116
+ disposeAll(created);
117
+ } catch {
118
+ // Preserve the mapper failure after all new entries are disposed.
119
+ }
120
+ throw error;
121
+ }
122
+ if (disposed) {
123
+ disposeAll(created);
124
+ return [];
125
+ }
126
+ let removed: Entry<T, U>[] = [];
127
+ if (entries.length !== next.length - created.length) {
128
+ const retained = new Set(next);
129
+ removed = entries.filter((entry) => !retained.has(entry));
130
+ }
131
+ const reordered = next.some((entry, index) => entry !== entries[index]);
132
+ entries = next;
133
+ if (owner && reordered) {
134
+ const pending = [...owner.children];
135
+ owner.children.clear();
136
+ for (const entry of next)
137
+ if (entry.scope) owner.children.add(entry.scope);
138
+ // Deferred removals remain owned until their explicit commit/disposal.
139
+ for (const child of pending) owner.children.add(child);
140
+ }
141
+ batch(() => {
142
+ next.forEach((entry, index) => entry.index(index));
143
+ if (reordered) getRenderScheduler()?.reorder();
144
+ if (deferRemoved && removed.length) {
145
+ try {
146
+ deferRemoved(() => disposeAll(removed));
147
+ } catch (error) {
148
+ try {
149
+ disposeAll(removed);
150
+ } catch {}
151
+ throw error;
152
+ }
153
+ } else disposeAll(removed);
154
+ });
155
+ return disposed ? [] : next.map((entry) => entry.value);
156
+ });
157
+ }
158
+
159
+ /** Retain each position while its item accessor follows the current list value. */
160
+ export function indexArray<T, U>(
161
+ list: Accessor<readonly T[]>,
162
+ map: (item: Accessor<T>, index: number) => U,
163
+ schedule: (read: () => U[]) => Accessor<U[]> = createRenderMemo,
164
+ ): Accessor<U[]> {
165
+ const owner = getRenderScheduler()
166
+ ? createComponentScope(() => getOwner()!)
167
+ : undefined;
168
+ let entries: Array<{
169
+ value: U;
170
+ dispose: () => void;
171
+ write: Setter<T>;
172
+ scope?: Owner;
173
+ }> = [];
174
+ let disposed = false;
175
+ onCleanup(() => {
176
+ disposed = true;
177
+ const previous = entries;
178
+ entries = [];
179
+ disposeAll(previous);
180
+ });
181
+ return schedule(() => {
182
+ const items = list();
183
+ const next = entries.slice(0, items.length);
184
+ const created: typeof entries = [];
185
+ try {
186
+ for (let index = next.length; index < items.length; index++) {
187
+ if (disposed) break;
188
+ const [item, write] = createSignal<T>(items[index]!);
189
+ const entry = {
190
+ ...owned(() => map(item, index), undefined, owner),
191
+ write,
192
+ };
193
+ created.push(entry);
194
+ next.push(entry);
195
+ }
196
+ } catch (error) {
197
+ try {
198
+ disposeAll(created);
199
+ } catch {
200
+ // Preserve the mapper failure after all new entries are disposed.
201
+ }
202
+ throw error;
203
+ }
204
+ if (disposed) {
205
+ disposeAll(created);
206
+ return [];
207
+ }
208
+ const removed = entries.slice(items.length);
209
+ entries = next;
210
+ batch(() => {
211
+ next.forEach((entry, index) => entry.write(() => items[index]!));
212
+ disposeAll(removed);
213
+ });
214
+ return disposed ? [] : next.map((entry) => entry.value);
215
+ });
216
+ }
217
+
218
+ export function Index<T, U>(props: {
219
+ each: Accessor<readonly T[]>;
220
+ children: (item: Accessor<T>, index: number) => U;
221
+ }): Accessor<U[]> {
222
+ return indexArray(props.each, props.children);
223
+ }
224
+
225
+ export function For<T, U>(
226
+ props: {
227
+ each: Accessor<readonly T[]>;
228
+ children: (item: T, index: Accessor<number>) => U;
229
+ },
230
+ schedule: (read: () => U[]) => Accessor<U[]> = createRenderMemo,
231
+ ): Accessor<U[]> {
232
+ return mapArray(props.each, props.children, undefined, schedule);
233
+ }
234
+
235
+ export function Show<T, U>(
236
+ props: {
237
+ when: Accessor<T>;
238
+ children: (value: Accessor<NonNullable<T>>) => U;
239
+ fallback?: () => U;
240
+ },
241
+ schedule: (
242
+ read: () => U | undefined,
243
+ ) => Accessor<U | undefined> = createRenderMemo,
244
+ cache: <V>(read: () => V) => Accessor<V> = createMemo,
245
+ ): Accessor<U | undefined> {
246
+ const owner = getRenderScheduler() ? getOwner() : undefined;
247
+ let branch: { value: U | undefined; dispose: () => void } | undefined;
248
+ let visible: boolean | undefined;
249
+ let disposed = false;
250
+ onCleanup(() => {
251
+ disposed = true;
252
+ branch?.dispose();
253
+ branch = undefined;
254
+ });
255
+ const value = cache(props.when);
256
+ if (disposed) return () => undefined;
257
+ const condition = cache(() => Boolean(value()));
258
+ if (disposed) return () => undefined;
259
+ return schedule(() => {
260
+ if (disposed) return undefined;
261
+ const nextVisible = condition();
262
+ if (visible !== nextVisible) {
263
+ branch?.dispose();
264
+ branch = undefined;
265
+ visible = undefined;
266
+ if (disposed) return undefined;
267
+ branch = owned(
268
+ () =>
269
+ nextVisible
270
+ ? props.children(() => {
271
+ const current = value();
272
+ if (!current) throw new Error("Show branch is inactive");
273
+ return current as NonNullable<T>;
274
+ })
275
+ : props.fallback?.(),
276
+ undefined,
277
+ owner,
278
+ );
279
+ if (disposed) {
280
+ const cancelled = branch;
281
+ branch = undefined;
282
+ cancelled.dispose();
283
+ return undefined;
284
+ }
285
+ visible = nextVisible;
286
+ }
287
+ return branch?.value;
288
+ });
289
+ }
290
+
291
+ const MATCH = /* @__PURE__ */ Symbol("moonshine-match");
292
+ export type MatchBranch<T, U> = {
293
+ readonly [MATCH]: true;
294
+ readonly when: Accessor<T>;
295
+ readonly children: (value: Accessor<NonNullable<T>>) => U;
296
+ };
297
+ /** Describe a branch without evaluating its condition or creating its contents. */
298
+ export function Match<T, U>(props: {
299
+ when: Accessor<T>;
300
+ children: (value: Accessor<NonNullable<T>>) => U;
301
+ }): MatchBranch<T, U> {
302
+ return { [MATCH]: true, when: props.when, children: props.children };
303
+ }
304
+
305
+ /** First truthy branch wins; retained branches keep their owner and live value. */
306
+ export function Switch<U>(props: {
307
+ children: Accessor<readonly MatchBranch<any, U>[]>;
308
+ fallback?: () => U;
309
+ }): Accessor<U | undefined> {
310
+ const owner = getRenderScheduler() ? getOwner() : undefined;
311
+ let current: MatchBranch<any, U> | undefined;
312
+ let branch: { value: U | undefined; dispose: () => void } | undefined;
313
+ let initialized = false;
314
+ let disposed = false;
315
+ onCleanup(() => {
316
+ disposed = true;
317
+ branch?.dispose();
318
+ branch = undefined;
319
+ });
320
+ const branches = createMemo(props.children);
321
+ if (disposed) return () => undefined;
322
+ const selection = createMemo(() => {
323
+ for (const candidate of branches()) {
324
+ if (!candidate || candidate[MATCH] !== true)
325
+ throw new TypeError("Switch children must be Match branches");
326
+ const value = candidate.when();
327
+ if (value) return { candidate, value };
328
+ }
329
+ return undefined;
330
+ });
331
+ if (disposed) return () => undefined;
332
+ const selected = createMemo(() => selection()?.candidate);
333
+ return createRenderMemo(() => {
334
+ const next = selected();
335
+ if (!initialized || current !== next) {
336
+ branch?.dispose();
337
+ branch = undefined;
338
+ initialized = false;
339
+ current = undefined;
340
+ if (disposed) return undefined;
341
+ branch = owned(
342
+ () =>
343
+ next
344
+ ? next.children(() => {
345
+ const chosen = selection();
346
+ if (chosen?.candidate !== next)
347
+ throw new Error("Match branch is inactive");
348
+ return chosen.value;
349
+ })
350
+ : props.fallback?.(),
351
+ undefined,
352
+ owner,
353
+ );
354
+ if (disposed) {
355
+ const cancelled = branch;
356
+ branch = undefined;
357
+ cancelled.dispose();
358
+ return undefined;
359
+ }
360
+ current = next;
361
+ initialized = true;
362
+ }
363
+ return branch?.value;
364
+ });
365
+ }
366
+
367
+ export { ErrorBoundary } from "./error";
@@ -0,0 +1,54 @@
1
+ /** Opt-in compiler writes for HTML custom elements; ordinary h props are unchanged. */
2
+ import { runWithOwner, untrack } from "./reactive";
3
+
4
+ export function setCustomElementValue(
5
+ node: HTMLElement,
6
+ name: string,
7
+ value: unknown,
8
+ ): void {
9
+ if (
10
+ node.namespaceURI !== "http://www.w3.org/1999/xhtml" ||
11
+ !node.localName.includes("-")
12
+ )
13
+ throw new TypeError(
14
+ "Custom element values require a hyphenated HTML element",
15
+ );
16
+ if (typeof name !== "string" || /^on/i.test(name))
17
+ throw new TypeError("Custom element events must use event listeners");
18
+ // Let the DOM validate names, including names outside ASCII, before setters run.
19
+ node.ownerDocument.createAttribute(name);
20
+ runWithOwner(null, () =>
21
+ untrack(() => {
22
+ const lower = name.toLowerCase();
23
+ const attributeOnly =
24
+ lower === "style" ||
25
+ lower === "innerhtml" ||
26
+ lower === "outerhtml" ||
27
+ lower === "textcontent" ||
28
+ lower === "innertext" ||
29
+ lower === "__proto__";
30
+ let property = false;
31
+ if (!attributeOnly) {
32
+ const view = node.ownerDocument.defaultView;
33
+ if (view?.customElements.get(node.localName)) {
34
+ const boundary = view.Element.prototype;
35
+ for (
36
+ let proto: object | null = node;
37
+ proto && proto !== boundary;
38
+ proto = Object.getPrototypeOf(proto)
39
+ ) {
40
+ if (Object.getOwnPropertyDescriptor(proto, name)?.set) {
41
+ property = true;
42
+ break;
43
+ }
44
+ }
45
+ } else property = value !== null && typeof value === "object";
46
+ }
47
+ if (property) {
48
+ if (!Reflect.set(node, name, value))
49
+ throw new TypeError(`Cannot set custom element property ${name}`);
50
+ } else if (value == null) node.removeAttribute(name);
51
+ else node.setAttribute(name, String(value));
52
+ }),
53
+ );
54
+ }