@tschk/moonshine-svelte 0.4.4 → 0.4.80
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 +171 -12
- package/package.json +17 -5
- package/src/abort-signal.ts +60 -0
- package/src/animate.ts +71 -0
- package/src/attachments.ts +93 -0
- package/src/binding.ts +3 -2
- package/src/class.ts +57 -0
- package/src/derived.ts +35 -5
- package/src/easing.ts +176 -0
- package/src/effect.ts +25 -5
- package/src/events.ts +76 -0
- package/src/kit.ts +1973 -0
- package/src/legacy.ts +361 -0
- package/src/motion.ts +504 -0
- package/src/navigation.ts +1134 -0
- package/src/pre.ts +98 -6
- package/src/prop-id.ts +43 -0
- package/src/reactivity-window.ts +173 -0
- package/src/reactivity.ts +983 -0
- package/src/runes.ts +5 -0
- package/src/server.ts +56 -0
- package/src/spread-element-dom.ts +343 -0
- package/src/spread-element-server.ts +106 -0
- package/src/spread-select.ts +86 -0
- package/src/ssr.ts +38 -3
- package/src/store-demand.ts +18 -0
- package/src/store-interop.ts +145 -0
- package/src/store.ts +7 -0
- package/src/svelte.ts +30 -1
- package/src/tick-queue.ts +3 -0
- package/src/transition.ts +348 -0
package/src/legacy.ts
ADDED
|
@@ -0,0 +1,361 @@
|
|
|
1
|
+
/** Independent Svelte 5 `svelte/legacy` migration helpers using Moonshine's native runtime. */
|
|
2
|
+
import {
|
|
3
|
+
componentEvents,
|
|
4
|
+
peekComponentContext,
|
|
5
|
+
} from "@tschk/moonshine-dom/component";
|
|
6
|
+
import {
|
|
7
|
+
createComputed,
|
|
8
|
+
getOwner,
|
|
9
|
+
getRenderScheduler,
|
|
10
|
+
onCleanup,
|
|
11
|
+
untrack,
|
|
12
|
+
} from "@tschk/moonshine-dom/reactive";
|
|
13
|
+
import { isSSRRendering } from "@tschk/moonshine-dom/ssr-owner";
|
|
14
|
+
import { mount, unmount } from "./mount";
|
|
15
|
+
import { createRunePreEffect } from "./pre";
|
|
16
|
+
import { createState } from "./runes";
|
|
17
|
+
import { createEventDispatcher, flushSync } from "./svelte";
|
|
18
|
+
|
|
19
|
+
/**
|
|
20
|
+
* Runs a function inside a pre-effect (replacing Svelte 4 `$: { ... }` statements),
|
|
21
|
+
* or executes it once synchronously during SSR.
|
|
22
|
+
*/
|
|
23
|
+
export function run(fn: () => void | (() => void)): void {
|
|
24
|
+
if (typeof fn !== "function") {
|
|
25
|
+
throw new TypeError("svelte/legacy run() requires a callback function");
|
|
26
|
+
}
|
|
27
|
+
if (isSSRRendering() || peekComponentContext()?.mode === "ssr") {
|
|
28
|
+
fn();
|
|
29
|
+
return;
|
|
30
|
+
}
|
|
31
|
+
if (getRenderScheduler()) {
|
|
32
|
+
createRunePreEffect(fn);
|
|
33
|
+
return;
|
|
34
|
+
}
|
|
35
|
+
if (getOwner()) {
|
|
36
|
+
let cleanup: (() => void) | void;
|
|
37
|
+
createComputed(() => {
|
|
38
|
+
if (typeof cleanup === "function") {
|
|
39
|
+
untrack(cleanup);
|
|
40
|
+
cleanup = undefined;
|
|
41
|
+
}
|
|
42
|
+
cleanup = fn();
|
|
43
|
+
});
|
|
44
|
+
onCleanup(() => {
|
|
45
|
+
if (typeof cleanup === "function") {
|
|
46
|
+
untrack(cleanup);
|
|
47
|
+
cleanup = undefined;
|
|
48
|
+
}
|
|
49
|
+
});
|
|
50
|
+
return;
|
|
51
|
+
}
|
|
52
|
+
fn();
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
export type LegacyEventHandler<E extends Event = Event, T = any> =
|
|
56
|
+
((this: T, event: E) => void) | null | undefined;
|
|
57
|
+
|
|
58
|
+
/** Composes multiple event handlers in order, preserving the `this` receiver. */
|
|
59
|
+
export function handlers<E extends Event = Event, T = any>(
|
|
60
|
+
...fns: Array<LegacyEventHandler<E, T>>
|
|
61
|
+
): (this: T, event: E) => void {
|
|
62
|
+
return function (this: T, event: E) {
|
|
63
|
+
for (const fn of fns) {
|
|
64
|
+
if (typeof fn === "function") {
|
|
65
|
+
Reflect.apply(fn, this, [event]);
|
|
66
|
+
}
|
|
67
|
+
}
|
|
68
|
+
};
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
/** Wraps an event handler so it is invoked at most once. */
|
|
72
|
+
export function once<E extends Event = Event, T = any>(
|
|
73
|
+
fn: LegacyEventHandler<E, T>,
|
|
74
|
+
): (this: T, event: E) => void {
|
|
75
|
+
let ran = false;
|
|
76
|
+
return function (this: T, event: E) {
|
|
77
|
+
if (ran) return;
|
|
78
|
+
ran = true;
|
|
79
|
+
if (typeof fn === "function") {
|
|
80
|
+
Reflect.apply(fn, this, [event]);
|
|
81
|
+
}
|
|
82
|
+
};
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
/** Calls `event.preventDefault()` before running `fn`. */
|
|
86
|
+
export function preventDefault<E extends Event = Event, T = any>(
|
|
87
|
+
fn: LegacyEventHandler<E, T>,
|
|
88
|
+
): (this: T, event: E) => void {
|
|
89
|
+
return function (this: T, event: E) {
|
|
90
|
+
event.preventDefault();
|
|
91
|
+
if (typeof fn === "function") {
|
|
92
|
+
Reflect.apply(fn, this, [event]);
|
|
93
|
+
}
|
|
94
|
+
};
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/** Calls `event.stopPropagation()` before running `fn`. */
|
|
98
|
+
export function stopPropagation<E extends Event = Event, T = any>(
|
|
99
|
+
fn: LegacyEventHandler<E, T>,
|
|
100
|
+
): (this: T, event: E) => void {
|
|
101
|
+
return function (this: T, event: E) {
|
|
102
|
+
event.stopPropagation();
|
|
103
|
+
if (typeof fn === "function") {
|
|
104
|
+
Reflect.apply(fn, this, [event]);
|
|
105
|
+
}
|
|
106
|
+
};
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
/** Calls `event.stopImmediatePropagation()` before running `fn`. */
|
|
110
|
+
export function stopImmediatePropagation<E extends Event = Event, T = any>(
|
|
111
|
+
fn: LegacyEventHandler<E, T>,
|
|
112
|
+
): (this: T, event: E) => void {
|
|
113
|
+
return function (this: T, event: E) {
|
|
114
|
+
event.stopImmediatePropagation();
|
|
115
|
+
if (typeof fn === "function") {
|
|
116
|
+
Reflect.apply(fn, this, [event]);
|
|
117
|
+
}
|
|
118
|
+
};
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
/** Invokes `fn` only when `event.target === event.currentTarget`. */
|
|
122
|
+
export function self<E extends Event = Event, T = any>(
|
|
123
|
+
fn: LegacyEventHandler<E, T>,
|
|
124
|
+
): (this: T, event: E) => void {
|
|
125
|
+
return function (this: T, event: E) {
|
|
126
|
+
if (event.target === event.currentTarget && typeof fn === "function") {
|
|
127
|
+
Reflect.apply(fn, this, [event]);
|
|
128
|
+
}
|
|
129
|
+
};
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
/** Invokes `fn` only when `event.isTrusted === true`. */
|
|
133
|
+
export function trusted<E extends Event = Event, T = any>(
|
|
134
|
+
fn: LegacyEventHandler<E, T>,
|
|
135
|
+
): (this: T, event: E) => void {
|
|
136
|
+
return function (this: T, event: E) {
|
|
137
|
+
if (event.isTrusted && typeof fn === "function") {
|
|
138
|
+
Reflect.apply(fn, this, [event]);
|
|
139
|
+
}
|
|
140
|
+
};
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
export type PassiveActionParams = [
|
|
144
|
+
event: string,
|
|
145
|
+
handler:
|
|
146
|
+
(() => EventListener | null | undefined) | EventListener | null | undefined,
|
|
147
|
+
];
|
|
148
|
+
|
|
149
|
+
function listenWithPassiveFlag(
|
|
150
|
+
node: EventTarget,
|
|
151
|
+
initialParams: PassiveActionParams,
|
|
152
|
+
passiveFlag: boolean,
|
|
153
|
+
): { update(nextParams: PassiveActionParams): void; destroy(): void } {
|
|
154
|
+
let currentEvent = initialParams[0];
|
|
155
|
+
let currentHandler = initialParams[1];
|
|
156
|
+
const listener: EventListener = function (this: any, e: Event) {
|
|
157
|
+
if (typeof currentHandler === "function") {
|
|
158
|
+
const result = Reflect.apply(currentHandler, this, [e]);
|
|
159
|
+
if (typeof result === "function") {
|
|
160
|
+
Reflect.apply(result, this, [e]);
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
};
|
|
164
|
+
node.addEventListener(currentEvent, listener, { passive: passiveFlag });
|
|
165
|
+
return {
|
|
166
|
+
update(nextParams: PassiveActionParams) {
|
|
167
|
+
const [nextEvent, nextHandler] = nextParams;
|
|
168
|
+
if (nextEvent !== currentEvent) {
|
|
169
|
+
node.removeEventListener(currentEvent, listener);
|
|
170
|
+
currentEvent = nextEvent;
|
|
171
|
+
node.addEventListener(currentEvent, listener, { passive: passiveFlag });
|
|
172
|
+
}
|
|
173
|
+
currentHandler = nextHandler;
|
|
174
|
+
},
|
|
175
|
+
destroy() {
|
|
176
|
+
node.removeEventListener(currentEvent, listener);
|
|
177
|
+
},
|
|
178
|
+
};
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
/** Action attaching an event listener with `{ passive: true }`. */
|
|
182
|
+
export function passive(
|
|
183
|
+
node: EventTarget,
|
|
184
|
+
params: PassiveActionParams,
|
|
185
|
+
): { update(nextParams: PassiveActionParams): void; destroy(): void } {
|
|
186
|
+
return listenWithPassiveFlag(node, params, true);
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
/** Action attaching an event listener with `{ passive: false }`. */
|
|
190
|
+
export function nonpassive(
|
|
191
|
+
node: EventTarget,
|
|
192
|
+
params: PassiveActionParams,
|
|
193
|
+
): { update(nextParams: PassiveActionParams): void; destroy(): void } {
|
|
194
|
+
return listenWithPassiveFlag(node, params, false);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
/** Creates an event bubbler function `bubble(type)` for forwarding DOM/component events. */
|
|
198
|
+
export function createBubbler(): (type: string) => (event: Event) => boolean {
|
|
199
|
+
const hasComponent = Boolean(peekComponentContext()?.active);
|
|
200
|
+
const dispatch = hasComponent ? createEventDispatcher() : undefined;
|
|
201
|
+
return (type: string) => (event: Event) => {
|
|
202
|
+
if (!dispatch) {
|
|
203
|
+
if (
|
|
204
|
+
event &&
|
|
205
|
+
event.currentTarget &&
|
|
206
|
+
typeof (event.currentTarget as EventTarget).dispatchEvent === "function"
|
|
207
|
+
) {
|
|
208
|
+
return true;
|
|
209
|
+
}
|
|
210
|
+
return true;
|
|
211
|
+
}
|
|
212
|
+
const detail = event instanceof CustomEvent ? event.detail : undefined;
|
|
213
|
+
return dispatch(type, detail, { cancelable: event.cancelable });
|
|
214
|
+
};
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
export interface LegacyComponentConstructorOptions<
|
|
218
|
+
Props extends Record<string, any> = Record<string, any>,
|
|
219
|
+
> {
|
|
220
|
+
target: Element | ShadowRoot;
|
|
221
|
+
anchor?: Node;
|
|
222
|
+
props?: Props;
|
|
223
|
+
context?: Map<any, any>;
|
|
224
|
+
intro?: boolean;
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
export interface LegacySvelteComponentInstance<
|
|
228
|
+
Props extends Record<string, any> = Record<string, any>,
|
|
229
|
+
> {
|
|
230
|
+
$set(props: Partial<Props>): void;
|
|
231
|
+
$on(type: string, callback: (event: CustomEvent<any>) => void): () => void;
|
|
232
|
+
$destroy(): void;
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
/**
|
|
236
|
+
* Imperatively instantiates a Svelte 5 component with a Svelte 4 class instance API
|
|
237
|
+
* (`$set`, `$on`, `$destroy`).
|
|
238
|
+
*/
|
|
239
|
+
export function createClassComponent<
|
|
240
|
+
Props extends Record<string, any> = Record<string, any>,
|
|
241
|
+
Exports extends Record<string, any> = Record<string, any>,
|
|
242
|
+
>(
|
|
243
|
+
options: LegacyComponentConstructorOptions<Props> & {
|
|
244
|
+
component: (props: Props) => any;
|
|
245
|
+
},
|
|
246
|
+
): Exports & LegacySvelteComponentInstance<Props> {
|
|
247
|
+
const {
|
|
248
|
+
component,
|
|
249
|
+
target,
|
|
250
|
+
anchor,
|
|
251
|
+
props: initialProps,
|
|
252
|
+
context,
|
|
253
|
+
intro,
|
|
254
|
+
} = options;
|
|
255
|
+
const listeners = new Map<string, Set<(event: CustomEvent<any>) => void>>();
|
|
256
|
+
const eventsRecord: Record<
|
|
257
|
+
string,
|
|
258
|
+
Array<(event: CustomEvent<any>) => void>
|
|
259
|
+
> = {};
|
|
260
|
+
|
|
261
|
+
const syncEventListeners = (type: string) => {
|
|
262
|
+
const set = listeners.get(type);
|
|
263
|
+
eventsRecord[type] = set ? [...set] : [];
|
|
264
|
+
};
|
|
265
|
+
|
|
266
|
+
const reactiveProps = createState<Record<string, any>>({
|
|
267
|
+
...initialProps,
|
|
268
|
+
}).value;
|
|
269
|
+
|
|
270
|
+
const proxyProps = new Proxy(reactiveProps, {
|
|
271
|
+
get(obj, key) {
|
|
272
|
+
if (key === componentEvents) return eventsRecord;
|
|
273
|
+
return Reflect.get(obj, key, obj);
|
|
274
|
+
},
|
|
275
|
+
has(obj, key) {
|
|
276
|
+
if (key === componentEvents) return true;
|
|
277
|
+
return Reflect.has(obj, key);
|
|
278
|
+
},
|
|
279
|
+
}) as Props;
|
|
280
|
+
|
|
281
|
+
const mountedExports = mount(component as any, {
|
|
282
|
+
target,
|
|
283
|
+
anchor,
|
|
284
|
+
props: proxyProps as never,
|
|
285
|
+
context,
|
|
286
|
+
intro,
|
|
287
|
+
}) as Record<string, any>;
|
|
288
|
+
|
|
289
|
+
const api: LegacySvelteComponentInstance<Props> = {
|
|
290
|
+
$set(nextProps: Partial<Props>) {
|
|
291
|
+
flushSync(() => {
|
|
292
|
+
for (const [key, value] of Object.entries(nextProps)) {
|
|
293
|
+
reactiveProps[key] = value;
|
|
294
|
+
}
|
|
295
|
+
});
|
|
296
|
+
},
|
|
297
|
+
$on(type: string, callback: (event: CustomEvent<any>) => void) {
|
|
298
|
+
let set = listeners.get(type);
|
|
299
|
+
if (!set) {
|
|
300
|
+
set = new Set();
|
|
301
|
+
listeners.set(type, set);
|
|
302
|
+
}
|
|
303
|
+
set.add(callback);
|
|
304
|
+
syncEventListeners(type);
|
|
305
|
+
return () => {
|
|
306
|
+
set?.delete(callback);
|
|
307
|
+
syncEventListeners(type);
|
|
308
|
+
};
|
|
309
|
+
},
|
|
310
|
+
$destroy() {
|
|
311
|
+
void unmount(mountedExports);
|
|
312
|
+
},
|
|
313
|
+
};
|
|
314
|
+
|
|
315
|
+
return new Proxy(api as Exports & LegacySvelteComponentInstance<Props>, {
|
|
316
|
+
get(targetObj, prop, receiver) {
|
|
317
|
+
if (prop in targetObj) {
|
|
318
|
+
return Reflect.get(targetObj, prop, receiver);
|
|
319
|
+
}
|
|
320
|
+
return Reflect.get(mountedExports, prop, mountedExports);
|
|
321
|
+
},
|
|
322
|
+
set(targetObj, prop, value, receiver) {
|
|
323
|
+
if (prop in targetObj) {
|
|
324
|
+
return Reflect.set(targetObj, prop, value, receiver);
|
|
325
|
+
}
|
|
326
|
+
flushSync(() => {
|
|
327
|
+
reactiveProps[String(prop)] = value;
|
|
328
|
+
});
|
|
329
|
+
return true;
|
|
330
|
+
},
|
|
331
|
+
has(targetObj, prop) {
|
|
332
|
+
return prop in targetObj || prop in mountedExports;
|
|
333
|
+
},
|
|
334
|
+
});
|
|
335
|
+
}
|
|
336
|
+
|
|
337
|
+
/**
|
|
338
|
+
* Wraps a Svelte 5 functional component into a Svelte 4 class constructor
|
|
339
|
+
* supporting `new Comp({ target, props })`, `$set`, `$on`, and `$destroy`.
|
|
340
|
+
*/
|
|
341
|
+
export function asClassComponent<
|
|
342
|
+
Props extends Record<string, any> = Record<string, any>,
|
|
343
|
+
Exports extends Record<string, any> = Record<string, any>,
|
|
344
|
+
>(
|
|
345
|
+
component: (props: Props) => any,
|
|
346
|
+
): new (
|
|
347
|
+
options: LegacyComponentConstructorOptions<Props>,
|
|
348
|
+
) => Exports & LegacySvelteComponentInstance<Props> {
|
|
349
|
+
function LegacyComponentWrapper(
|
|
350
|
+
this: unknown,
|
|
351
|
+
options: LegacyComponentConstructorOptions<Props>,
|
|
352
|
+
) {
|
|
353
|
+
return createClassComponent<Props, Exports>({
|
|
354
|
+
...options,
|
|
355
|
+
component,
|
|
356
|
+
});
|
|
357
|
+
}
|
|
358
|
+
return LegacyComponentWrapper as unknown as new (
|
|
359
|
+
options: LegacyComponentConstructorOptions<Props>,
|
|
360
|
+
) => Exports & LegacySvelteComponentInstance<Props>;
|
|
361
|
+
}
|