@tschk/moonshine-vue 0.4.49 → 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/src/app.ts CHANGED
@@ -1,6 +1,22 @@
1
- import { createComponent } from "@tschk/moonshine-dom/component";
1
+ import {
2
+ createComponent,
3
+ peekComponentContext,
4
+ type ComponentContext,
5
+ } from "@tschk/moonshine-dom/component";
2
6
  import { flushComponentReferences } from "@tschk/moonshine-dom/component-instance";
3
7
  import { render, type DOMChild } from "@tschk/moonshine-dom/dom";
8
+ import { getOwner, onCleanup } from "@tschk/moonshine-dom/reactive";
9
+ import { h as hSSR, type SSRChild } from "@tschk/moonshine-dom/ssr";
10
+ import {
11
+ appContextKey,
12
+ peekAppContext,
13
+ withActiveAppContext,
14
+ type AppConfig,
15
+ type AppContextState,
16
+ type InjectionKey,
17
+ } from "./context";
18
+ import { componentErrorKey, type ComponentErrorInfo } from "./error-context";
19
+ export type { AppConfig } from "./context";
4
20
  export type { ShallowUnwrap } from "./expose";
5
21
 
6
22
  /** Erased return metadata supplied only by the native SFC compiler. */
@@ -37,11 +53,129 @@ type ExportsOf<R> = [Metadata<R>] extends [never]
37
53
  ? E
38
54
  : object;
39
55
 
56
+ export interface DirectiveBinding<
57
+ V = any,
58
+ M extends string = string,
59
+ A extends string = string,
60
+ > {
61
+ instance: ComponentContext | null;
62
+ value: V;
63
+ oldValue: V | null;
64
+ arg?: A;
65
+ modifiers: Partial<Record<M, boolean>>;
66
+ dir: ObjectDirective<any, V, M, A>;
67
+ }
68
+
69
+ export type DirectiveHook<
70
+ HostElement = any,
71
+ V = any,
72
+ M extends string = string,
73
+ A extends string = string,
74
+ > = (
75
+ el: HostElement,
76
+ binding: DirectiveBinding<V, M, A>,
77
+ vnode?: null,
78
+ prevVNode?: null,
79
+ ) => void;
80
+
81
+ export interface ObjectDirective<
82
+ HostElement = any,
83
+ V = any,
84
+ M extends string = string,
85
+ A extends string = string,
86
+ > {
87
+ created?: DirectiveHook<HostElement, V, M, A>;
88
+ beforeMount?: DirectiveHook<HostElement, V, M, A>;
89
+ mounted?: DirectiveHook<HostElement, V, M, A>;
90
+ beforeUpdate?: DirectiveHook<HostElement, V, M, A>;
91
+ updated?: DirectiveHook<HostElement, V, M, A>;
92
+ beforeUnmount?: DirectiveHook<HostElement, V, M, A>;
93
+ unmounted?: DirectiveHook<HostElement, V, M, A>;
94
+ getSSRProps?: (
95
+ binding: DirectiveBinding<V, M, A>,
96
+ vnode?: null,
97
+ ) => Record<string, any> | undefined;
98
+ deep?: boolean;
99
+ }
100
+
101
+ export type FunctionDirective<
102
+ HostElement = any,
103
+ V = any,
104
+ M extends string = string,
105
+ A extends string = string,
106
+ > = DirectiveHook<HostElement, V, M, A>;
107
+
108
+ export type Directive<
109
+ HostElement = any,
110
+ V = any,
111
+ M extends string = string,
112
+ A extends string = string,
113
+ > =
114
+ | ObjectDirective<HostElement, V, M, A>
115
+ | FunctionDirective<HostElement, V, M, A>;
116
+
117
+ export type DirectiveArguments = Array<
118
+ | [Directive | undefined]
119
+ | [Directive | undefined, any]
120
+ | [Directive | undefined, any, string]
121
+ | [Directive | undefined, any, string | undefined, Record<string, boolean>]
122
+ >;
123
+
124
+ export type FunctionPlugin<Options = any[]> = Options extends unknown[]
125
+ ? (app: NativeApplication<any>, ...options: Options) => any
126
+ : (app: NativeApplication<any>, options: Options) => any;
127
+
128
+ export type ObjectPlugin<Options = any[]> = {
129
+ install: FunctionPlugin<Options>;
130
+ };
131
+
132
+ export type Plugin<Options = any[]> =
133
+ FunctionPlugin<Options> | ObjectPlugin<Options>;
134
+
135
+ export function definePlugin<Options = any[]>(
136
+ plugin: Plugin<Options>,
137
+ ): Plugin<Options> {
138
+ return plugin;
139
+ }
140
+
141
+ export const renderAppSSRSymbol = /* @__PURE__ */ Symbol(
142
+ "moonshine.vue.app.ssr",
143
+ );
144
+
40
145
  export interface NativeApplication<out E extends object = object> {
146
+ readonly version: string;
147
+ readonly config: AppConfig;
148
+ readonly _context: {
149
+ app: NativeApplication<any>;
150
+ config: AppConfig;
151
+ mixins: Array<Record<string, any>>;
152
+ components: Record<string, (...args: any[]) => any>;
153
+ directives: Record<string, Directive>;
154
+ provides: Record<PropertyKey, unknown>;
155
+ };
156
+ use<Options extends unknown[]>(
157
+ plugin: Plugin<Options>,
158
+ ...options: Options
159
+ ): this;
160
+ use<Options>(plugin: Plugin<Options>, options: Options): this;
161
+ provide<T>(key: InjectionKey<T> | string | number, value: T): this;
162
+ runWithContext<T>(fn: () => T): T;
163
+ component(name: string): ((...args: any[]) => any) | undefined;
164
+ component<T extends (...args: any[]) => any>(
165
+ name: string,
166
+ component: T,
167
+ ): this;
168
+ directive(name: string): Directive | undefined;
169
+ directive(name: string, directive: Directive): this;
170
+ mixin(mixin: Record<string, any>): this;
171
+ onUnmount(cb: () => void): void;
41
172
  mount(target: string | Element | ShadowRoot): E;
42
173
  unmount(): void;
174
+ readonly [renderAppSSRSymbol]?: () => SSRChild;
43
175
  }
44
176
 
177
+ export type App<E extends object = object> = NativeApplication<E>;
178
+
45
179
  const emptyInstance: object = /* @__PURE__ */ Object.freeze(
46
180
  /* @__PURE__ */ Object.create(null),
47
181
  );
@@ -64,15 +198,68 @@ function content(value: DOMChild): DOMChild {
64
198
  return value;
65
199
  }
66
200
 
201
+ function attachAppOwnerContext(appState: AppContextState): void {
202
+ const scope = getOwner();
203
+ if (!scope) return;
204
+ scope.context = new Map(scope.context);
205
+ scope.context.set(appContextKey, appState);
206
+ scope.context.set(
207
+ componentErrorKey,
208
+ (error: unknown, info: ComponentErrorInfo) => {
209
+ if (appState.config.errorHandler) {
210
+ appState.config.errorHandler(error, info.component, info.phase);
211
+ } else {
212
+ throw error;
213
+ }
214
+ },
215
+ );
216
+ }
217
+
67
218
  /** Mount a native compiled/component factory; this does not execute Vue VNodes. */
68
- export function createApp<P extends object, R extends DOMChild = DOMChild>(
219
+ export function createApp<R extends DOMChild>(
220
+ component: (props?: Record<string, never>) => R,
221
+ ): NativeApplication<ExportsOf<R>>;
222
+ export function createApp<P extends object, R extends DOMChild>(
69
223
  component: (props: P) => R,
70
224
  props: P,
71
- ): NativeApplication<ExportsOf<R>> {
225
+ ): NativeApplication<ExportsOf<R>>;
226
+ export function createApp<
227
+ P extends object = Record<string, any>,
228
+ R extends DOMChild = DOMChild,
229
+ >(component: (props: P) => R, props?: P): NativeApplication<ExportsOf<R>> {
72
230
  if (typeof component !== "function")
73
231
  throw new TypeError("Native applications require a component factory");
74
- if (props === null || typeof props !== "object" || Array.isArray(props))
232
+ const resolvedProps = (arguments.length > 1 ? props : ({} as P)) as P;
233
+ if (
234
+ resolvedProps === null ||
235
+ typeof resolvedProps !== "object" ||
236
+ Array.isArray(resolvedProps)
237
+ )
75
238
  throw new TypeError("Native application props must be an object");
239
+
240
+ const config: AppConfig = {
241
+ errorHandler: undefined,
242
+ warnHandler: undefined,
243
+ globalProperties: {},
244
+ performance: false,
245
+ idPrefix: undefined,
246
+ compilerOptions: {},
247
+ optionMergeStrategies: {},
248
+ throwUnhandledErrorInProduction: false,
249
+ };
250
+
251
+ const appState: AppContextState = {
252
+ provides: new Map(),
253
+ components: new Map(),
254
+ directives: new Map(),
255
+ mixins: [],
256
+ config,
257
+ idState: { next: 0 },
258
+ };
259
+
260
+ const installedPlugins = new Set<unknown>();
261
+ const unmountCallbacks: Array<() => void> = [];
262
+
76
263
  let state: "new" | "mounting" | "mounted" | "stopped" = "new";
77
264
  let stop: (() => void) | undefined;
78
265
  const stopped = () => state === "stopped";
@@ -81,10 +268,48 @@ export function createApp<P extends object, R extends DOMChild = DOMChild>(
81
268
  state = "stopped";
82
269
  const dispose = stop;
83
270
  stop = undefined;
84
- dispose?.();
271
+ let firstError: unknown;
272
+ let hasError = false;
273
+ try {
274
+ dispose?.();
275
+ } catch (err) {
276
+ firstError = err;
277
+ hasError = true;
278
+ }
279
+ for (const cb of unmountCallbacks.splice(0)) {
280
+ try {
281
+ cb();
282
+ } catch (err) {
283
+ if (config.errorHandler) {
284
+ config.errorHandler(err, undefined, "app unmount");
285
+ } else if (!hasError) {
286
+ firstError = err;
287
+ hasError = true;
288
+ }
289
+ }
290
+ }
291
+ if (hasError) {
292
+ throw firstError;
293
+ }
294
+ };
295
+
296
+ const componentsRecord: Record<string, (...args: any[]) => any> = {};
297
+ const directivesRecord: Record<string, Directive> = {};
298
+ const providesRecord: Record<PropertyKey, unknown> = Object.create(null);
299
+
300
+ const appContextObj = {
301
+ get app() {
302
+ return app;
303
+ },
304
+ config,
305
+ mixins: appState.mixins,
306
+ components: componentsRecord,
307
+ directives: directivesRecord,
308
+ provides: providesRecord,
85
309
  };
86
- const app: NativeApplication<ExportsOf<R>> = {
87
- mount(target) {
310
+
311
+ const app = {
312
+ mount(target: string | Element | ShadowRoot) {
88
313
  if (state !== "new")
89
314
  throw new Error("Native application cannot be mounted again");
90
315
  if (typeof document === "undefined")
@@ -110,11 +335,12 @@ export function createApp<P extends object, R extends DOMChild = DOMChild>(
110
335
  release();
111
336
  return emptyInstance as ExportsOf<R>;
112
337
  }
113
- const dispose = render(
114
- () =>
338
+ const dispose = render(() => {
339
+ attachAppOwnerContext(appState);
340
+ return withActiveAppContext(appState, () =>
115
341
  createComponent(
116
342
  (input: P) => content(component(input)),
117
- props,
343
+ resolvedProps,
118
344
  "dom",
119
345
  {
120
346
  capture: (value) => {
@@ -122,8 +348,8 @@ export function createApp<P extends object, R extends DOMChild = DOMChild>(
122
348
  },
123
349
  },
124
350
  ),
125
- container,
126
- );
351
+ );
352
+ }, container);
127
353
  const finish = () => {
128
354
  try {
129
355
  dispose();
@@ -145,6 +371,193 @@ export function createApp<P extends object, R extends DOMChild = DOMChild>(
145
371
  }
146
372
  },
147
373
  unmount,
148
- };
374
+ [renderAppSSRSymbol]() {
375
+ appState.idState.next = 0;
376
+ attachAppOwnerContext(appState);
377
+ return withActiveAppContext(appState, () =>
378
+ hSSR(component as unknown as (props: P) => SSRChild, resolvedProps),
379
+ );
380
+ },
381
+ } as NativeApplication<ExportsOf<R>>;
382
+
383
+ Object.defineProperties(app, {
384
+ version: { value: "3.5.13", writable: false, configurable: true },
385
+ config: { value: config, writable: false, configurable: true },
386
+ _context: { value: appContextObj, writable: false, configurable: true },
387
+ use: {
388
+ value(plugin: Plugin<any>, ...options: any[]) {
389
+ if (installedPlugins.has(plugin)) {
390
+ return app;
391
+ }
392
+ if (plugin && typeof (plugin as ObjectPlugin).install === "function") {
393
+ installedPlugins.add(plugin);
394
+ withActiveAppContext(appState, () =>
395
+ (plugin as ObjectPlugin).install(app, ...options),
396
+ );
397
+ } else if (typeof plugin === "function") {
398
+ installedPlugins.add(plugin);
399
+ withActiveAppContext(appState, () =>
400
+ (plugin as (...args: any[]) => any)(app, ...options),
401
+ );
402
+ }
403
+ return app;
404
+ },
405
+ writable: true,
406
+ configurable: true,
407
+ },
408
+ provide: {
409
+ value(key: PropertyKey, value: unknown) {
410
+ appState.provides.set(key, value);
411
+ providesRecord[key] = value;
412
+ return app;
413
+ },
414
+ writable: true,
415
+ configurable: true,
416
+ },
417
+ runWithContext: {
418
+ value<T>(fn: () => T): T {
419
+ return withActiveAppContext(appState, fn);
420
+ },
421
+ writable: true,
422
+ configurable: true,
423
+ },
424
+ component: {
425
+ value(name: string, comp?: (...args: any[]) => any): any {
426
+ if (comp === undefined) {
427
+ return appState.components.get(name);
428
+ }
429
+ appState.components.set(name, comp);
430
+ componentsRecord[name] = comp;
431
+ return app;
432
+ },
433
+ writable: true,
434
+ configurable: true,
435
+ },
436
+ directive: {
437
+ value(name: string, dir?: Directive): any {
438
+ if (dir === undefined) {
439
+ return appState.directives.get(name);
440
+ }
441
+ appState.directives.set(name, dir);
442
+ directivesRecord[name] = dir;
443
+ return app;
444
+ },
445
+ writable: true,
446
+ configurable: true,
447
+ },
448
+ mixin: {
449
+ value(mixin: Record<string, any>) {
450
+ if (!appState.mixins.includes(mixin)) {
451
+ appState.mixins.push(mixin);
452
+ }
453
+ return app;
454
+ },
455
+ writable: true,
456
+ configurable: true,
457
+ },
458
+ onUnmount: {
459
+ value(cb: () => void) {
460
+ if (typeof cb === "function") {
461
+ unmountCallbacks.push(cb);
462
+ }
463
+ },
464
+ writable: true,
465
+ configurable: true,
466
+ },
467
+ });
149
468
  return app;
150
469
  }
470
+
471
+ /** Create an SSR-capable native Vue application instance. */
472
+ export function createSSRApp<P extends object = Record<string, any>, R = any>(
473
+ component: (props: P) => R,
474
+ props?: P,
475
+ ): NativeApplication<ExportsOf<R>> {
476
+ return (
477
+ arguments.length > 1
478
+ ? createApp(component as unknown as (props: P) => DOMChild, props!)
479
+ : createApp(component as unknown as () => DOMChild)
480
+ ) as NativeApplication<ExportsOf<R>>;
481
+ }
482
+
483
+ /** Resolve a globally registered component from the active application context. */
484
+ export function resolveComponent(
485
+ name: string,
486
+ ): ((...args: any[]) => any) | string {
487
+ const appCtx = peekAppContext();
488
+ return appCtx?.components.get(name) ?? name;
489
+ }
490
+
491
+ /** Resolve a globally registered custom directive from the active application context. */
492
+ export function resolveDirective(name: string): Directive | undefined {
493
+ return peekAppContext()?.directives.get(name);
494
+ }
495
+
496
+ /** Apply custom directives to a rendered DOM element or SSR props object. */
497
+ export function withDirectives<T>(node: T, directives: DirectiveArguments): T {
498
+ const instance = peekComponentContext() ?? null;
499
+ if (typeof Element !== "undefined" && node instanceof Element) {
500
+ for (const entry of directives) {
501
+ const dir = entry[0];
502
+ if (!dir) continue;
503
+ const value = entry[1];
504
+ const arg = entry[2];
505
+ const modifiers = entry[3] ?? {};
506
+ const dirObj: ObjectDirective =
507
+ typeof dir === "function" ? { mounted: dir, updated: dir } : dir;
508
+ const binding: DirectiveBinding = {
509
+ instance,
510
+ value,
511
+ oldValue: null,
512
+ arg,
513
+ modifiers,
514
+ dir: dirObj,
515
+ };
516
+ dirObj.created?.(node, binding, null, null);
517
+ dirObj.beforeMount?.(node, binding, null, null);
518
+ dirObj.mounted?.(node, binding, null, null);
519
+ if (getOwner() && (dirObj.beforeUnmount || dirObj.unmounted)) {
520
+ onCleanup(() => {
521
+ dirObj.beforeUnmount?.(node, binding, null, null);
522
+ dirObj.unmounted?.(node, binding, null, null);
523
+ });
524
+ }
525
+ }
526
+ return node;
527
+ }
528
+ if (node !== null && typeof node === "object" && !Array.isArray(node)) {
529
+ const merged: Record<string, any> = { ...(node as Record<string, any>) };
530
+ for (const entry of directives) {
531
+ const dir = entry[0];
532
+ if (!dir || typeof dir === "function") continue;
533
+ const value = entry[1];
534
+ const arg = entry[2];
535
+ const modifiers = entry[3] ?? {};
536
+ const binding: DirectiveBinding = {
537
+ instance,
538
+ value,
539
+ oldValue: null,
540
+ arg,
541
+ modifiers,
542
+ dir,
543
+ };
544
+ const ssrProps = dir.getSSRProps?.(binding, null);
545
+ if (ssrProps && typeof ssrProps === "object") {
546
+ Object.assign(merged, ssrProps);
547
+ }
548
+ }
549
+ return merged as T;
550
+ }
551
+ return node;
552
+ }
553
+
554
+ /** Emit a warning through the active application's `config.warnHandler` or `console.warn`. */
555
+ export function warn(msg: string, ...args: unknown[]): void {
556
+ const appCtx = peekAppContext();
557
+ const instance = peekComponentContext();
558
+ if (appCtx?.config.warnHandler) {
559
+ appCtx.config.warnHandler(msg, instance, "");
560
+ return;
561
+ }
562
+ console.warn(`[Vue warn]: ${msg}`, ...args);
563
+ }