@tschk/moonshine-svelte 0.0.0-stage → 0.4.49
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.
- package/README.md +594 -2
- package/package.json +57 -4
- package/src/await.ts +123 -0
- package/src/binding.ts +116 -0
- package/src/class.ts +78 -0
- package/src/const-derived.ts +47 -0
- package/src/derived.ts +276 -0
- package/src/directives.ts +129 -0
- package/src/each.ts +306 -0
- package/src/effect.ts +250 -0
- package/src/framework.ts +1 -0
- package/src/history.ts +104 -0
- package/src/index.ts +55 -0
- package/src/mount-types.ts +46 -0
- package/src/mount.ts +100 -0
- package/src/pre.ts +749 -0
- package/src/private-class-state.ts +54 -0
- package/src/prop.ts +64 -0
- package/src/raw-snippet-dom.ts +214 -0
- package/src/raw-snippet-ssr.ts +75 -0
- package/src/raw-snippet.ts +36 -0
- package/src/raw-ssr-lifecycle.ts +8 -0
- package/src/raw-state.ts +19 -0
- package/src/runes.ts +15 -0
- package/src/server-mount.ts +31 -0
- package/src/server-prop.ts +29 -0
- package/src/server-store.ts +113 -0
- package/src/spread-element-dom.ts +343 -0
- package/src/spread-element-server.ts +106 -0
- package/src/spread-props.ts +153 -0
- package/src/spread-select.ts +86 -0
- package/src/ssr.ts +54 -0
- package/src/state.ts +492 -0
- package/src/store-binding.ts +125 -0
- package/src/store-demand.ts +18 -0
- package/src/store-internal.ts +34 -0
- package/src/store-interop.ts +145 -0
- package/src/store-write.ts +38 -0
- package/src/store.ts +215 -0
- package/src/svelte.ts +152 -0
- package/src/tick-queue.ts +31 -0
|
@@ -0,0 +1,343 @@
|
|
|
1
|
+
import { sourceAttributeValue } from "@tschk/moonshine-dom/attributes";
|
|
2
|
+
import { setInputValue, setOptionValue } from "@tschk/moonshine-dom/binding";
|
|
3
|
+
import {
|
|
4
|
+
createComponentScope,
|
|
5
|
+
createRenderEffect,
|
|
6
|
+
getOwner,
|
|
7
|
+
getRenderScheduler,
|
|
8
|
+
onAfterDispose,
|
|
9
|
+
onCleanup,
|
|
10
|
+
runWithOwner,
|
|
11
|
+
templateRetentionKey,
|
|
12
|
+
untrack,
|
|
13
|
+
} from "@tschk/moonshine-dom/reactive";
|
|
14
|
+
import { isSSRRendering } from "@tschk/moonshine-dom/ssr-owner";
|
|
15
|
+
import { peekComponentContext } from "@tschk/moonshine-dom/component";
|
|
16
|
+
import { classValue } from "./class";
|
|
17
|
+
import { withHistoryCleanup } from "./history";
|
|
18
|
+
import { createSpreadSelect } from "./spread-select";
|
|
19
|
+
|
|
20
|
+
const ATTRIBUTE_NAME = /^[a-zA-Z_:][a-zA-Z0-9:_.-]*$/;
|
|
21
|
+
const CONTENT = /* @__PURE__ */ new Set([
|
|
22
|
+
"innerhtml",
|
|
23
|
+
"outerhtml",
|
|
24
|
+
"textcontent",
|
|
25
|
+
"innertext",
|
|
26
|
+
]);
|
|
27
|
+
const ALIASES: Record<string, string> = {
|
|
28
|
+
formnovalidate: "formNoValidate",
|
|
29
|
+
ismap: "isMap",
|
|
30
|
+
nomodule: "noModule",
|
|
31
|
+
playsinline: "playsInline",
|
|
32
|
+
readonly: "readOnly",
|
|
33
|
+
defaultvalue: "defaultValue",
|
|
34
|
+
defaultchecked: "defaultChecked",
|
|
35
|
+
srcobject: "srcObject",
|
|
36
|
+
novalidate: "noValidate",
|
|
37
|
+
allowfullscreen: "allowFullscreen",
|
|
38
|
+
disablepictureinpicture: "disablePictureInPicture",
|
|
39
|
+
disableremoteplayback: "disableRemotePlayback",
|
|
40
|
+
};
|
|
41
|
+
|
|
42
|
+
type Handler = (this: unknown, event: Event) => unknown;
|
|
43
|
+
interface Listener {
|
|
44
|
+
type: string;
|
|
45
|
+
capture: boolean;
|
|
46
|
+
handler: Handler;
|
|
47
|
+
wrapper: (this: unknown, event: Event) => unknown;
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
function install(fn: () => void): void {
|
|
51
|
+
if (isSSRRendering() || peekComponentContext()?.mode === "ssr") return;
|
|
52
|
+
const owner = getOwner(),
|
|
53
|
+
scheduler = getRenderScheduler();
|
|
54
|
+
if (!owner || owner.disposed || !scheduler)
|
|
55
|
+
throw Error("Native directives require a live owner and withRuneScheduler");
|
|
56
|
+
createComponentScope(() => scheduler.branch(fn));
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
function cleanup(fn: () => void): void {
|
|
60
|
+
const finish = () => withHistoryCleanup(() => untrack(fn));
|
|
61
|
+
const owner = getOwner();
|
|
62
|
+
if (owner?.disposed) finish();
|
|
63
|
+
else if (owner?.context?.has(templateRetentionKey))
|
|
64
|
+
onCleanup(() => runWithOwner(owner, finish));
|
|
65
|
+
else onAfterDispose(finish);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
function setters(element: Element): Set<string> {
|
|
69
|
+
const found = new Set<string>();
|
|
70
|
+
const stop = Element.prototype;
|
|
71
|
+
for (
|
|
72
|
+
let proto: object | null = element;
|
|
73
|
+
proto && proto !== stop;
|
|
74
|
+
proto = Object.getPrototypeOf(proto)
|
|
75
|
+
) {
|
|
76
|
+
const descriptors = Object.getOwnPropertyDescriptors(proto);
|
|
77
|
+
for (const key of Object.keys(descriptors))
|
|
78
|
+
if (descriptors[key]!.set && !CONTENT.has(key.toLowerCase()))
|
|
79
|
+
found.add(key);
|
|
80
|
+
}
|
|
81
|
+
return found;
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
/** Eager null-prototype merge: every thunk and getter is read exactly once, later layers win. */
|
|
85
|
+
function snapshot(layers: readonly unknown[]): Record<string, unknown> {
|
|
86
|
+
const merged: Record<string, unknown> = Object.create(null);
|
|
87
|
+
for (let index = 0; index < layers.length; index++) {
|
|
88
|
+
const layer = layers[index];
|
|
89
|
+
const source = typeof layer === "function" ? layer() : layer;
|
|
90
|
+
if (source != null) Object.assign(merged, source);
|
|
91
|
+
}
|
|
92
|
+
return merged;
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
/**
|
|
96
|
+
* Ordinary HTML intrinsic spread for compiler-owned DOM output.
|
|
97
|
+
* Events attach directly (no delegation) with Svelte's case-preserving names and `capture` suffix.
|
|
98
|
+
* Namespaces, custom elements, autofocus and scoped directives remain unsupported.
|
|
99
|
+
*/
|
|
100
|
+
export function installElementSpread(
|
|
101
|
+
element: Element,
|
|
102
|
+
...layers: unknown[]
|
|
103
|
+
): void {
|
|
104
|
+
installSpread(element, [], layers);
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
/** Compiler-owned bindings install once; details toggle handlers precede binding writes. */
|
|
108
|
+
export function installBoundElementSpread<T extends Element>(
|
|
109
|
+
element: T,
|
|
110
|
+
bindings: readonly ((element: T) => void)[],
|
|
111
|
+
...layers: unknown[]
|
|
112
|
+
): void {
|
|
113
|
+
installSpread(
|
|
114
|
+
element,
|
|
115
|
+
bindings.map((bind) => () => bind(element)),
|
|
116
|
+
layers,
|
|
117
|
+
);
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
function installSpread(
|
|
121
|
+
element: Element,
|
|
122
|
+
bindings: readonly (() => void)[],
|
|
123
|
+
layers: readonly unknown[],
|
|
124
|
+
): void {
|
|
125
|
+
install(() => {
|
|
126
|
+
const scope = getOwner()!;
|
|
127
|
+
const bindAfterEvents = element.tagName === "DETAILS";
|
|
128
|
+
const bindAll = () =>
|
|
129
|
+
runWithOwner(scope, () =>
|
|
130
|
+
untrack(() => {
|
|
131
|
+
for (const bind of bindings) bind();
|
|
132
|
+
}),
|
|
133
|
+
);
|
|
134
|
+
const applied = new Map<string, unknown>();
|
|
135
|
+
const listeners = new Map<string, Listener>();
|
|
136
|
+
let known: Set<string> | undefined;
|
|
137
|
+
const input =
|
|
138
|
+
element.tagName === "INPUT" ? (element as HTMLInputElement) : undefined;
|
|
139
|
+
const valueElement =
|
|
140
|
+
input ??
|
|
141
|
+
(element.tagName === "TEXTAREA"
|
|
142
|
+
? (element as HTMLTextAreaElement)
|
|
143
|
+
: undefined);
|
|
144
|
+
let initial = true;
|
|
145
|
+
const select =
|
|
146
|
+
element.tagName === "SELECT"
|
|
147
|
+
? createSpreadSelect(element as HTMLSelectElement, (run) => {
|
|
148
|
+
if (bindings.length) run();
|
|
149
|
+
else getRenderScheduler()!.post(run);
|
|
150
|
+
})
|
|
151
|
+
: undefined;
|
|
152
|
+
if (select) cleanup(select.dispose);
|
|
153
|
+
|
|
154
|
+
const release = (key: string): void => {
|
|
155
|
+
const listener = listeners.get(key);
|
|
156
|
+
if (!listener) return;
|
|
157
|
+
listeners.delete(key);
|
|
158
|
+
element.removeEventListener(listener.type, listener.wrapper, {
|
|
159
|
+
capture: listener.capture,
|
|
160
|
+
});
|
|
161
|
+
};
|
|
162
|
+
|
|
163
|
+
cleanup(() => {
|
|
164
|
+
for (const key of listeners.keys()) release(key);
|
|
165
|
+
applied.clear();
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
createRenderEffect(() => {
|
|
169
|
+
const merged = snapshot(layers);
|
|
170
|
+
const attributes = new Map<string, unknown>();
|
|
171
|
+
const events = new Map<string, unknown>();
|
|
172
|
+
const keys = Object.keys(merged);
|
|
173
|
+
for (let index = 0; index < keys.length; index++) {
|
|
174
|
+
const key = keys[index]!;
|
|
175
|
+
const value = merged[key];
|
|
176
|
+
if (key.startsWith("$$")) continue;
|
|
177
|
+
if (key.length > 2 && key.startsWith("on")) {
|
|
178
|
+
events.set(key, value);
|
|
179
|
+
continue;
|
|
180
|
+
}
|
|
181
|
+
// Keep the native SSR event filter: never install inline handler strings.
|
|
182
|
+
if (/^on/i.test(key)) continue;
|
|
183
|
+
const name = key.toLowerCase();
|
|
184
|
+
if (CONTENT.has(name))
|
|
185
|
+
throw new TypeError(
|
|
186
|
+
`Spread attribute ${JSON.stringify(key)} would overwrite element content`,
|
|
187
|
+
);
|
|
188
|
+
if (typeof value === "function" || !ATTRIBUTE_NAME.test(key)) continue;
|
|
189
|
+
attributes.set(
|
|
190
|
+
key,
|
|
191
|
+
key === "class"
|
|
192
|
+
? classValue(value)
|
|
193
|
+
: name === "style" && value != null
|
|
194
|
+
? String(value)
|
|
195
|
+
: value,
|
|
196
|
+
);
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
// Missing raw keys follow current keys, including case variants of one HTML name.
|
|
200
|
+
for (const key of applied.keys()) {
|
|
201
|
+
if (!attributes.has(key)) attributes.set(key, null);
|
|
202
|
+
}
|
|
203
|
+
if (
|
|
204
|
+
input &&
|
|
205
|
+
attributes.has("type") &&
|
|
206
|
+
(attributes.has("value") || attributes.has("__value"))
|
|
207
|
+
) {
|
|
208
|
+
const type = attributes.get("type");
|
|
209
|
+
if (
|
|
210
|
+
applied.get("type") !== type ||
|
|
211
|
+
(type === undefined && input.hasAttribute("type"))
|
|
212
|
+
) {
|
|
213
|
+
if (type == null) input.removeAttribute("type");
|
|
214
|
+
else input.setAttribute("type", String(type));
|
|
215
|
+
applied.set("type", type);
|
|
216
|
+
}
|
|
217
|
+
}
|
|
218
|
+
for (const [key, value] of attributes) {
|
|
219
|
+
const name = key.toLowerCase();
|
|
220
|
+
if (select && (key === "value" || key === "defaultValue")) {
|
|
221
|
+
if (
|
|
222
|
+
key === "value" &&
|
|
223
|
+
(!applied.has(key) || applied.get(key) !== value)
|
|
224
|
+
)
|
|
225
|
+
(element as HTMLSelectElement).value =
|
|
226
|
+
value == null ? "" : String(value);
|
|
227
|
+
applied.set(key, value);
|
|
228
|
+
continue;
|
|
229
|
+
}
|
|
230
|
+
if (element.tagName === "OPTION" && key === "value") {
|
|
231
|
+
// Spread option null/removal means the empty typed value, not label fallback.
|
|
232
|
+
if (value == null || !applied.has(key) || applied.get(key) !== value)
|
|
233
|
+
setOptionValue(element as HTMLOptionElement, value ?? "");
|
|
234
|
+
applied.set(key, value);
|
|
235
|
+
continue;
|
|
236
|
+
}
|
|
237
|
+
if (
|
|
238
|
+
applied.has(key) &&
|
|
239
|
+
applied.get(key) === value &&
|
|
240
|
+
!(value === undefined && element.hasAttribute(name))
|
|
241
|
+
)
|
|
242
|
+
continue;
|
|
243
|
+
if (element.tagName === "OPTION" && key === "selected") {
|
|
244
|
+
if (value) element.setAttribute("selected", "");
|
|
245
|
+
else element.removeAttribute("selected");
|
|
246
|
+
applied.set(key, value);
|
|
247
|
+
continue;
|
|
248
|
+
}
|
|
249
|
+
if (
|
|
250
|
+
valueElement &&
|
|
251
|
+
(key === "__value" || (key === "value" && value != null))
|
|
252
|
+
) {
|
|
253
|
+
if (input) setInputValue(input, value, !bindings.length);
|
|
254
|
+
else valueElement.value = value as string;
|
|
255
|
+
} else if (input && name === "defaultchecked") {
|
|
256
|
+
input.defaultChecked = value as boolean;
|
|
257
|
+
} else if (input && name === "checked" && value == null) {
|
|
258
|
+
const reset = input.defaultChecked;
|
|
259
|
+
input.removeAttribute(name);
|
|
260
|
+
input.defaultChecked = reset;
|
|
261
|
+
input.checked = initial ? reset : false;
|
|
262
|
+
} else if (valueElement && name === "defaultvalue") {
|
|
263
|
+
valueElement.defaultValue = value as string;
|
|
264
|
+
} else if (valueElement && name === "value" && value == null) {
|
|
265
|
+
const reset = valueElement.defaultValue;
|
|
266
|
+
valueElement.removeAttribute(name);
|
|
267
|
+
valueElement.defaultValue = reset;
|
|
268
|
+
const next = initial ? reset : null;
|
|
269
|
+
if (input) setInputValue(input, next, !bindings.length);
|
|
270
|
+
else valueElement.value = next ?? "";
|
|
271
|
+
} else if (input && name === "checked" && typeof value !== "string") {
|
|
272
|
+
input.checked = value as boolean;
|
|
273
|
+
} else if (
|
|
274
|
+
input &&
|
|
275
|
+
typeof value === "boolean" &&
|
|
276
|
+
(known ??= setters(element)).has(ALIASES[name] ?? name)
|
|
277
|
+
) {
|
|
278
|
+
(input as unknown as Record<string, unknown>)[ALIASES[name] ?? name] =
|
|
279
|
+
value;
|
|
280
|
+
} else if (value == null) {
|
|
281
|
+
element.removeAttribute(name);
|
|
282
|
+
} else if (name === "style") {
|
|
283
|
+
(element as HTMLElement).style.cssText = value as string;
|
|
284
|
+
} else {
|
|
285
|
+
const property = ALIASES[name] ?? name;
|
|
286
|
+
if (
|
|
287
|
+
typeof value !== "string" &&
|
|
288
|
+
typeof value !== "boolean" &&
|
|
289
|
+
(known ??= setters(element)).has(property)
|
|
290
|
+
) {
|
|
291
|
+
(element as unknown as Record<string, unknown>)[property] = value;
|
|
292
|
+
} else {
|
|
293
|
+
const text =
|
|
294
|
+
name === "class"
|
|
295
|
+
? (value as string)
|
|
296
|
+
: sourceAttributeValue(name, value, true);
|
|
297
|
+
if (text === undefined) element.removeAttribute(name);
|
|
298
|
+
else element.setAttribute(name, text);
|
|
299
|
+
}
|
|
300
|
+
}
|
|
301
|
+
applied.set(key, value);
|
|
302
|
+
}
|
|
303
|
+
select?.update(attributes);
|
|
304
|
+
|
|
305
|
+
for (const key of listeners.keys())
|
|
306
|
+
if (typeof events.get(key) !== "function") release(key);
|
|
307
|
+
for (const capturePhase of [true, false]) {
|
|
308
|
+
if (!capturePhase && initial && bindings.length && !bindAfterEvents)
|
|
309
|
+
bindAll();
|
|
310
|
+
for (const [key, value] of events) {
|
|
311
|
+
if (typeof value !== "function") continue;
|
|
312
|
+
const eventType = key.slice(2);
|
|
313
|
+
const eventCapture =
|
|
314
|
+
eventType.endsWith("capture") &&
|
|
315
|
+
eventType !== "gotpointercapture" &&
|
|
316
|
+
eventType !== "lostpointercapture";
|
|
317
|
+
if (eventCapture !== capturePhase) continue;
|
|
318
|
+
const existing = listeners.get(key);
|
|
319
|
+
if (existing) {
|
|
320
|
+
existing.handler = value as Handler;
|
|
321
|
+
continue;
|
|
322
|
+
}
|
|
323
|
+
let type = eventType;
|
|
324
|
+
const capture = eventCapture;
|
|
325
|
+
if (capture) type = type.slice(0, -7);
|
|
326
|
+
if (!type) continue;
|
|
327
|
+
const listener: Listener = {
|
|
328
|
+
type,
|
|
329
|
+
capture,
|
|
330
|
+
handler: value as Handler,
|
|
331
|
+
wrapper(this: unknown, event: Event) {
|
|
332
|
+
return listener.handler.call(this, event);
|
|
333
|
+
},
|
|
334
|
+
};
|
|
335
|
+
listeners.set(key, listener);
|
|
336
|
+
element.addEventListener(type, listener.wrapper, { capture });
|
|
337
|
+
}
|
|
338
|
+
}
|
|
339
|
+
if (initial && bindings.length && bindAfterEvents) bindAll();
|
|
340
|
+
initial = false;
|
|
341
|
+
});
|
|
342
|
+
});
|
|
343
|
+
}
|
|
@@ -0,0 +1,106 @@
|
|
|
1
|
+
import { sourceAttributeValue } from "@tschk/moonshine-dom/attributes";
|
|
2
|
+
import { classValue } from "./class";
|
|
3
|
+
import {
|
|
4
|
+
hAttributeEntries,
|
|
5
|
+
hSelectionEntries,
|
|
6
|
+
type SSRChild,
|
|
7
|
+
} from "@tschk/moonshine-dom/ssr";
|
|
8
|
+
|
|
9
|
+
const ATTRIBUTE_NAME = /^[a-zA-Z_:][a-zA-Z0-9:_.-]*$/;
|
|
10
|
+
const EVENT_NAME = /^on/i;
|
|
11
|
+
|
|
12
|
+
/** Compiler-owned form spread; selection retains source identity through lazy SSR children. */
|
|
13
|
+
export function spreadServerElement(
|
|
14
|
+
tag: "input" | "textarea" | "select" | "option",
|
|
15
|
+
layers: readonly unknown[],
|
|
16
|
+
...children: SSRChild[]
|
|
17
|
+
): SSRChild {
|
|
18
|
+
const merged = merge(layers);
|
|
19
|
+
if (tag === "select") {
|
|
20
|
+
return hSelectionEntries(
|
|
21
|
+
"select",
|
|
22
|
+
entriesFromMerged(merged, "select"),
|
|
23
|
+
{
|
|
24
|
+
value: merged.value === undefined ? merged.defaultValue : merged.value,
|
|
25
|
+
preserveSelected: true,
|
|
26
|
+
},
|
|
27
|
+
...children,
|
|
28
|
+
);
|
|
29
|
+
}
|
|
30
|
+
if (tag === "option" && Object.hasOwn(merged, "value"))
|
|
31
|
+
return hSelectionEntries(
|
|
32
|
+
"option",
|
|
33
|
+
entriesFromMerged(merged),
|
|
34
|
+
{ value: merged.value },
|
|
35
|
+
...children,
|
|
36
|
+
);
|
|
37
|
+
return hAttributeEntries(
|
|
38
|
+
tag,
|
|
39
|
+
entriesFromMerged(merged, tag === "input" ? "input" : undefined),
|
|
40
|
+
...children,
|
|
41
|
+
);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
/**
|
|
45
|
+
* Ordinary HTML intrinsic spread for compiler-owned `hAttributeEntries` output.
|
|
46
|
+
* Layers merge eagerly like JS object spread, so each getter runs exactly once.
|
|
47
|
+
* Pass `"input"` for input defaults; other form elements need their own lowering.
|
|
48
|
+
*/
|
|
49
|
+
export function spreadServerEntries(
|
|
50
|
+
layers: readonly unknown[],
|
|
51
|
+
element?: "input",
|
|
52
|
+
): readonly (readonly [string, string | undefined])[] {
|
|
53
|
+
return entriesFromMerged(merge(layers), element);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
function merge(layers: readonly unknown[]): Record<string, unknown> {
|
|
57
|
+
// A null prototype keeps `__proto__` and inherited names ordinary data.
|
|
58
|
+
const merged: Record<string | symbol, unknown> = Object.create(null);
|
|
59
|
+
for (let index = 0; index < layers.length; index++) {
|
|
60
|
+
const layer = layers[index];
|
|
61
|
+
if (layer != null) Object.assign(merged, layer);
|
|
62
|
+
}
|
|
63
|
+
return merged;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
function entriesFromMerged(
|
|
67
|
+
merged: Record<string, unknown>,
|
|
68
|
+
element?: "input" | "select",
|
|
69
|
+
): readonly (readonly [string, string | undefined])[] {
|
|
70
|
+
const entries: Array<readonly [string, string | undefined]> = [];
|
|
71
|
+
const keys = Object.keys(merged);
|
|
72
|
+
let loweredKeys: string[] | undefined;
|
|
73
|
+
for (let index = 0; index < keys.length; index++) {
|
|
74
|
+
const key = keys[index]!;
|
|
75
|
+
if (element === "select" && (key === "value" || key === "defaultValue"))
|
|
76
|
+
continue;
|
|
77
|
+
const value = merged[key];
|
|
78
|
+
// Functions, event handlers and internal or invalid names are never attributes.
|
|
79
|
+
if (typeof value === "function" || !ATTRIBUTE_NAME.test(key)) continue;
|
|
80
|
+
if (EVENT_NAME.test(key)) continue;
|
|
81
|
+
let name = key.toLowerCase();
|
|
82
|
+
if (
|
|
83
|
+
element === "input" &&
|
|
84
|
+
(name === "defaultvalue" || name === "defaultchecked")
|
|
85
|
+
) {
|
|
86
|
+
name = name === "defaultvalue" ? "value" : "checked";
|
|
87
|
+
// Presence wins even for nullish values, functions and differently cased keys.
|
|
88
|
+
if (
|
|
89
|
+
Object.hasOwn(merged, name) ||
|
|
90
|
+
(loweredKeys ??= keys.map((candidate) =>
|
|
91
|
+
candidate.toLowerCase(),
|
|
92
|
+
)).includes(name)
|
|
93
|
+
)
|
|
94
|
+
continue;
|
|
95
|
+
}
|
|
96
|
+
entries.push([
|
|
97
|
+
name,
|
|
98
|
+
sourceAttributeValue(
|
|
99
|
+
name,
|
|
100
|
+
key === "class" ? classValue(value) : value,
|
|
101
|
+
true,
|
|
102
|
+
),
|
|
103
|
+
]);
|
|
104
|
+
}
|
|
105
|
+
return entries;
|
|
106
|
+
}
|
|
@@ -0,0 +1,153 @@
|
|
|
1
|
+
/** Compiler-facing prop layers; expression caching belongs to the compiler. */
|
|
2
|
+
export type PropLayer = object | null | undefined;
|
|
3
|
+
export type LivePropLayer = PropLayer | (() => PropLayer);
|
|
4
|
+
|
|
5
|
+
// Like object spread, broad index signatures do not erase statically named keys.
|
|
6
|
+
type Known<T> = {
|
|
7
|
+
[
|
|
8
|
+
K in keyof T as string extends K
|
|
9
|
+
? never
|
|
10
|
+
: number extends K
|
|
11
|
+
? never
|
|
12
|
+
: symbol extends K
|
|
13
|
+
? never
|
|
14
|
+
: K
|
|
15
|
+
]: T[K];
|
|
16
|
+
};
|
|
17
|
+
type IsAny<T> = 0 extends 1 & T ? true : false;
|
|
18
|
+
type LayerValue<T> = T extends () => infer V ? V : T;
|
|
19
|
+
type RequiredKeys<T> = {
|
|
20
|
+
[K in keyof T]-?: {} extends Pick<T, K> ? never : K;
|
|
21
|
+
}[keyof T];
|
|
22
|
+
type SpreadValue<A, B, K extends keyof A | keyof B> = K extends keyof B
|
|
23
|
+
? K extends RequiredKeys<B>
|
|
24
|
+
? B[K]
|
|
25
|
+
: B[K] | (K extends keyof A ? A[K] : never)
|
|
26
|
+
: K extends keyof A
|
|
27
|
+
? A[K]
|
|
28
|
+
: never;
|
|
29
|
+
type Merge<A, B> = A extends unknown
|
|
30
|
+
? B extends unknown
|
|
31
|
+
? B extends null | undefined
|
|
32
|
+
? A
|
|
33
|
+
: {
|
|
34
|
+
[K in RequiredKeys<A> | RequiredKeys<Known<B>>]: SpreadValue<
|
|
35
|
+
A,
|
|
36
|
+
Known<B>,
|
|
37
|
+
K
|
|
38
|
+
>;
|
|
39
|
+
} & {
|
|
40
|
+
[
|
|
41
|
+
K in Exclude<
|
|
42
|
+
keyof A | keyof Known<B>,
|
|
43
|
+
RequiredKeys<A> | RequiredKeys<Known<B>>
|
|
44
|
+
>
|
|
45
|
+
]?: SpreadValue<A, Known<B>, K>;
|
|
46
|
+
}
|
|
47
|
+
: never
|
|
48
|
+
: never;
|
|
49
|
+
type Layers<
|
|
50
|
+
Items extends readonly unknown[],
|
|
51
|
+
Acc = {},
|
|
52
|
+
> = Items extends readonly [infer Head, ...infer Tail]
|
|
53
|
+
? IsAny<LayerValue<Head>> extends true
|
|
54
|
+
? any
|
|
55
|
+
: Layers<Tail, Merge<Acc, LayerValue<Head>>>
|
|
56
|
+
: Acc;
|
|
57
|
+
export type SpreadProps<Items extends readonly LivePropLayer[]> =
|
|
58
|
+
number extends Items["length"] ? Record<PropertyKey, unknown> : Layers<Items>;
|
|
59
|
+
|
|
60
|
+
// Server snapshots enumerate Object.keys, unlike the live DOM proxy's symbols.
|
|
61
|
+
type WithoutSymbols<T> =
|
|
62
|
+
IsAny<T> extends true
|
|
63
|
+
? any
|
|
64
|
+
: T extends unknown
|
|
65
|
+
? { [K in keyof T as K extends symbol ? never : K]: T[K] }
|
|
66
|
+
: never;
|
|
67
|
+
export type SpreadServerProps<Items extends readonly PropLayer[]> =
|
|
68
|
+
number extends Items["length"]
|
|
69
|
+
? Record<PropertyKey, unknown>
|
|
70
|
+
: WithoutSymbols<Layers<Items>>;
|
|
71
|
+
|
|
72
|
+
function resolve(layer: LivePropLayer): PropLayer {
|
|
73
|
+
return typeof layer === "function" ? layer() : layer;
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
export function spreadProps<const Items extends readonly LivePropLayer[]>(
|
|
77
|
+
...layers: Items
|
|
78
|
+
): SpreadProps<Items>;
|
|
79
|
+
export function spreadProps(
|
|
80
|
+
...layers: LivePropLayer[]
|
|
81
|
+
): Record<PropertyKey, unknown> {
|
|
82
|
+
function descriptor(key: PropertyKey): PropertyDescriptor | undefined {
|
|
83
|
+
for (let index = layers.length - 1; index >= 0; index--) {
|
|
84
|
+
const layer = resolve(layers[index]!);
|
|
85
|
+
if (layer !== null && typeof layer === "object" && key in layer) {
|
|
86
|
+
const found = Object.getOwnPropertyDescriptor(layer, key);
|
|
87
|
+
return found ? { ...found, configurable: true } : undefined;
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
}
|
|
91
|
+
return new Proxy(
|
|
92
|
+
{},
|
|
93
|
+
{
|
|
94
|
+
get(_target, key) {
|
|
95
|
+
for (let index = layers.length - 1; index >= 0; index--) {
|
|
96
|
+
const layer = resolve(layers[index]!);
|
|
97
|
+
if (layer !== null && typeof layer === "object" && key in layer)
|
|
98
|
+
return Reflect.get(layer, key);
|
|
99
|
+
}
|
|
100
|
+
},
|
|
101
|
+
set(_target, key, value) {
|
|
102
|
+
for (let index = layers.length - 1; index >= 0; index--) {
|
|
103
|
+
const layer = resolve(layers[index]!);
|
|
104
|
+
// Nullish layers are absent during writes too, avoiding the host null-layer trap.
|
|
105
|
+
if (layer == null) continue;
|
|
106
|
+
const found = Object.getOwnPropertyDescriptor(layer, key);
|
|
107
|
+
if (found?.set) {
|
|
108
|
+
// Svelte forwards through the descriptor, including its receiver.
|
|
109
|
+
found.set(value);
|
|
110
|
+
return true;
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
return false;
|
|
114
|
+
},
|
|
115
|
+
has(_target, key) {
|
|
116
|
+
return layers.some((layer) => {
|
|
117
|
+
const value = resolve(layer);
|
|
118
|
+
return value != null && key in value;
|
|
119
|
+
});
|
|
120
|
+
},
|
|
121
|
+
ownKeys() {
|
|
122
|
+
const keys: Array<string | symbol> = [];
|
|
123
|
+
for (const source of layers) {
|
|
124
|
+
const layer = resolve(source);
|
|
125
|
+
if (layer == null) continue;
|
|
126
|
+
for (const key in layer) if (!keys.includes(key)) keys.push(key);
|
|
127
|
+
for (const key of Object.getOwnPropertySymbols(layer))
|
|
128
|
+
if (!keys.includes(key)) keys.push(key);
|
|
129
|
+
}
|
|
130
|
+
return keys;
|
|
131
|
+
},
|
|
132
|
+
getOwnPropertyDescriptor: (_target, key) => descriptor(key),
|
|
133
|
+
},
|
|
134
|
+
);
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
export function spreadServerProps<const Items extends readonly PropLayer[]>(
|
|
138
|
+
layers: Items,
|
|
139
|
+
): SpreadServerProps<Items>;
|
|
140
|
+
export function spreadServerProps(
|
|
141
|
+
layers: readonly PropLayer[],
|
|
142
|
+
): Record<PropertyKey, unknown> {
|
|
143
|
+
const merged: Record<PropertyKey, unknown> = {};
|
|
144
|
+
for (const layer of layers) {
|
|
145
|
+
if (layer == null) continue;
|
|
146
|
+
for (const key of Object.keys(layer)) {
|
|
147
|
+
const descriptor = Object.getOwnPropertyDescriptor(layer, key);
|
|
148
|
+
if (descriptor) Object.defineProperty(merged, key, descriptor);
|
|
149
|
+
else merged[key] = Reflect.get(layer, key);
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
return merged;
|
|
153
|
+
}
|
|
@@ -0,0 +1,86 @@
|
|
|
1
|
+
import { optionValue } from "@tschk/moonshine-dom/binding";
|
|
2
|
+
import { stateEquals } from "./state";
|
|
3
|
+
|
|
4
|
+
/** Compiler-owned select reconciliation, using the native typed-option store. */
|
|
5
|
+
export function createSpreadSelect(
|
|
6
|
+
select: HTMLSelectElement,
|
|
7
|
+
enqueue: (run: () => void) => void,
|
|
8
|
+
): {
|
|
9
|
+
update: (attributes: ReadonlyMap<string, unknown>) => void;
|
|
10
|
+
dispose: () => void;
|
|
11
|
+
} {
|
|
12
|
+
let attributes: ReadonlyMap<string, unknown> = new Map();
|
|
13
|
+
let initialized = false,
|
|
14
|
+
active = true,
|
|
15
|
+
defaultApplied = false;
|
|
16
|
+
let previousDefault: unknown;
|
|
17
|
+
function reconcile(mounting = false, optionsChanged = false): void {
|
|
18
|
+
if (!active) return;
|
|
19
|
+
const options = Array.from(select.options);
|
|
20
|
+
const defaultValue = attributes.get("defaultValue");
|
|
21
|
+
if (
|
|
22
|
+
attributes.has("defaultValue") &&
|
|
23
|
+
(!defaultApplied || previousDefault !== defaultValue || optionsChanged)
|
|
24
|
+
) {
|
|
25
|
+
const preserve =
|
|
26
|
+
!optionsChanged && (defaultApplied || attributes.has("value"));
|
|
27
|
+
const index = select.selectedIndex;
|
|
28
|
+
const selected = new Set(options.filter((option) => option.selected));
|
|
29
|
+
for (const option of options) {
|
|
30
|
+
const matches = select.multiple
|
|
31
|
+
? Array.isArray(defaultValue) &&
|
|
32
|
+
defaultValue.includes(optionValue(option))
|
|
33
|
+
: stateEquals(optionValue(option), defaultValue);
|
|
34
|
+
if (matches) {
|
|
35
|
+
if (!option.hasAttribute("selected"))
|
|
36
|
+
option.setAttribute("selected", "");
|
|
37
|
+
} else option.removeAttribute("selected");
|
|
38
|
+
}
|
|
39
|
+
if (preserve) {
|
|
40
|
+
if (select.multiple)
|
|
41
|
+
for (const option of options) option.selected = selected.has(option);
|
|
42
|
+
else select.selectedIndex = index;
|
|
43
|
+
}
|
|
44
|
+
previousDefault = defaultValue;
|
|
45
|
+
defaultApplied = true;
|
|
46
|
+
}
|
|
47
|
+
if (!mounting && !attributes.has("value")) return;
|
|
48
|
+
const value = attributes.get("value");
|
|
49
|
+
if (select.multiple) {
|
|
50
|
+
if (value == null || !Array.isArray(value)) return;
|
|
51
|
+
for (const option of options)
|
|
52
|
+
option.selected = value.includes(optionValue(option));
|
|
53
|
+
} else {
|
|
54
|
+
const found = options.find((option) =>
|
|
55
|
+
stateEquals(optionValue(option), value),
|
|
56
|
+
);
|
|
57
|
+
if (found) found.selected = true;
|
|
58
|
+
else if (!mounting || value !== undefined) select.selectedIndex = -1;
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
const observer = new MutationObserver(() => {
|
|
62
|
+
if (initialized) reconcile(false, true);
|
|
63
|
+
});
|
|
64
|
+
observer.observe(select, {
|
|
65
|
+
childList: true,
|
|
66
|
+
subtree: true,
|
|
67
|
+
attributes: true,
|
|
68
|
+
attributeFilter: ["value"],
|
|
69
|
+
});
|
|
70
|
+
return {
|
|
71
|
+
update(next) {
|
|
72
|
+
attributes = next;
|
|
73
|
+
if (initialized) reconcile();
|
|
74
|
+
else
|
|
75
|
+
enqueue(() => {
|
|
76
|
+
if (!active || initialized) return;
|
|
77
|
+
reconcile(true);
|
|
78
|
+
initialized = true;
|
|
79
|
+
});
|
|
80
|
+
},
|
|
81
|
+
dispose() {
|
|
82
|
+
active = false;
|
|
83
|
+
observer.disconnect();
|
|
84
|
+
},
|
|
85
|
+
};
|
|
86
|
+
}
|