@tschk/moonshine-vue 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/src/app.ts ADDED
@@ -0,0 +1,150 @@
1
+ import { createComponent } from "@tschk/moonshine-dom/component";
2
+ import { flushComponentReferences } from "@tschk/moonshine-dom/component-instance";
3
+ import { render, type DOMChild } from "@tschk/moonshine-dom/dom";
4
+ export type { ShallowUnwrap } from "./expose";
5
+
6
+ /** Erased return metadata supplied only by the native SFC compiler. */
7
+ declare const componentMetadata: unique symbol;
8
+ export type ComponentView<
9
+ View,
10
+ Exports extends object,
11
+ Props extends object = object,
12
+ > = View & {
13
+ readonly [componentMetadata]?: { props: Props; exports: Exports };
14
+ };
15
+ type Metadata<R> = [R] extends [never]
16
+ ? never
17
+ : typeof componentMetadata extends keyof NonNullable<R>
18
+ ? NonNullable<NonNullable<R>[typeof componentMetadata]>
19
+ : never;
20
+ export type ComponentProps<C extends (...args: never[]) => unknown> = [
21
+ Metadata<ReturnType<C>>,
22
+ ] extends [never]
23
+ ? never
24
+ : Metadata<ReturnType<C>> extends { props: infer P extends object }
25
+ ? P
26
+ : never;
27
+ export type ComponentExports<C extends (...args: never[]) => unknown> = [
28
+ Metadata<ReturnType<C>>,
29
+ ] extends [never]
30
+ ? never
31
+ : Metadata<ReturnType<C>> extends { exports: infer E extends object }
32
+ ? E
33
+ : never;
34
+ type ExportsOf<R> = [Metadata<R>] extends [never]
35
+ ? object
36
+ : Metadata<R> extends { exports: infer E extends object }
37
+ ? E
38
+ : object;
39
+
40
+ export interface NativeApplication<out E extends object = object> {
41
+ mount(target: string | Element | ShadowRoot): E;
42
+ unmount(): void;
43
+ }
44
+
45
+ const emptyInstance: object = /* @__PURE__ */ Object.freeze(
46
+ /* @__PURE__ */ Object.create(null),
47
+ );
48
+ const leases = /* @__PURE__ */ new WeakMap<
49
+ Element | ShadowRoot,
50
+ NativeApplication
51
+ >();
52
+
53
+ // Validate async/VNode results without evaluating accessor children ahead of insert.
54
+ function content(value: DOMChild): DOMChild {
55
+ if (typeof value === "function") return () => content(value());
56
+ if (Array.isArray(value)) return value.map(content);
57
+ if (value !== null && typeof value === "object" && !(value instanceof Node)) {
58
+ if (value instanceof Promise)
59
+ void Promise.prototype.then.call(value, undefined, () => {});
60
+ throw new TypeError(
61
+ "Native applications require DOM children, not promises or VNodes",
62
+ );
63
+ }
64
+ return value;
65
+ }
66
+
67
+ /** Mount a native compiled/component factory; this does not execute Vue VNodes. */
68
+ export function createApp<P extends object, R extends DOMChild = DOMChild>(
69
+ component: (props: P) => R,
70
+ props: P,
71
+ ): NativeApplication<ExportsOf<R>> {
72
+ if (typeof component !== "function")
73
+ throw new TypeError("Native applications require a component factory");
74
+ if (props === null || typeof props !== "object" || Array.isArray(props))
75
+ throw new TypeError("Native application props must be an object");
76
+ let state: "new" | "mounting" | "mounted" | "stopped" = "new";
77
+ let stop: (() => void) | undefined;
78
+ const stopped = () => state === "stopped";
79
+ const unmount = () => {
80
+ if (state === "new" || state === "stopped") return;
81
+ state = "stopped";
82
+ const dispose = stop;
83
+ stop = undefined;
84
+ dispose?.();
85
+ };
86
+ const app: NativeApplication<ExportsOf<R>> = {
87
+ mount(target) {
88
+ if (state !== "new")
89
+ throw new Error("Native application cannot be mounted again");
90
+ if (typeof document === "undefined")
91
+ throw new Error("Native application mount requires a DOM");
92
+ const container =
93
+ typeof target === "string" ? document.querySelector(target) : target;
94
+ if (!(container instanceof Element) && !(container instanceof ShadowRoot))
95
+ throw new TypeError(
96
+ "Native application mount target was not found or is invalid",
97
+ );
98
+ if (leases.has(container))
99
+ throw new Error("Native application mount target is already owned");
100
+ const release = () => {
101
+ if (leases.get(container) === app) leases.delete(container);
102
+ };
103
+ // Clearing and disposal can synchronously reenter another app mount.
104
+ leases.set(container, app);
105
+ state = "mounting";
106
+ let instance: object | undefined;
107
+ try {
108
+ container.replaceChildren();
109
+ if (stopped()) {
110
+ release();
111
+ return emptyInstance as ExportsOf<R>;
112
+ }
113
+ const dispose = render(
114
+ () =>
115
+ createComponent(
116
+ (input: P) => content(component(input)),
117
+ props,
118
+ "dom",
119
+ {
120
+ capture: (value) => {
121
+ instance = value;
122
+ },
123
+ },
124
+ ),
125
+ container,
126
+ );
127
+ const finish = () => {
128
+ try {
129
+ dispose();
130
+ } finally {
131
+ release();
132
+ }
133
+ };
134
+ if (stopped()) finish();
135
+ else {
136
+ flushComponentReferences();
137
+ stop = finish;
138
+ state = "mounted";
139
+ }
140
+ return (instance ?? emptyInstance) as ExportsOf<R>;
141
+ } catch (error) {
142
+ release();
143
+ state = "stopped";
144
+ throw error;
145
+ }
146
+ },
147
+ unmount,
148
+ };
149
+ return app;
150
+ }
@@ -0,0 +1 @@
1
+ export { parse, compileScript, compileTemplate } from "vue/compiler-sfc";
package/src/context.ts ADDED
@@ -0,0 +1,71 @@
1
+ /** Native component injection; no Vue app or public-instance runtime. */
2
+ import {
3
+ getComponentContext,
4
+ peekComponentContext,
5
+ setContext,
6
+ type ComponentContext,
7
+ } from "@tschk/moonshine-dom/component";
8
+ import { untrack, type Owner } from "@tschk/moonshine-dom/reactive";
9
+
10
+ declare const injectionType: unique symbol;
11
+ export type InjectionKey<T> = symbol & { readonly [injectionType]?: T };
12
+ const providesKey = Symbol("moonshine.vue.provides");
13
+ const idCounters = /* @__PURE__ */ new WeakMap<Owner, { next: number }>();
14
+ type Provides = {
15
+ frame: ComponentContext;
16
+ parent?: Provides;
17
+ values: Map<string | symbol, unknown>;
18
+ };
19
+ function layer(frame: ComponentContext): Provides | undefined {
20
+ return frame.contexts.get(providesKey) as Provides | undefined;
21
+ }
22
+ export function provide<T>(key: InjectionKey<T> | string, value: T): void {
23
+ const frame = getComponentContext();
24
+ let current = layer(frame);
25
+ if (current?.frame !== frame) {
26
+ current = { frame, parent: current, values: new Map() };
27
+ setContext(providesKey, current);
28
+ }
29
+ current.values.set(key, value);
30
+ }
31
+ export function inject<T>(key: InjectionKey<T> | string): T | undefined;
32
+ export function inject<T>(
33
+ key: InjectionKey<T> | string,
34
+ defaultValue: T,
35
+ treatDefaultAsFactory?: false,
36
+ ): T;
37
+ export function inject<T>(
38
+ key: InjectionKey<T> | string,
39
+ defaultValue: () => T,
40
+ treatDefaultAsFactory: true,
41
+ ): T;
42
+ export function inject<T>(
43
+ key: InjectionKey<T> | string,
44
+ defaultValue?: T | (() => T),
45
+ treatDefaultAsFactory = false,
46
+ ): T | undefined {
47
+ const frame = getComponentContext();
48
+ let current = layer(frame);
49
+ if (current?.frame === frame) current = current.parent;
50
+ for (; current; current = current.parent) {
51
+ if (current.values.has(key)) return current.values.get(key) as T;
52
+ }
53
+ return treatDefaultAsFactory && typeof defaultValue === "function"
54
+ ? untrack(() => (defaultValue as () => T)())
55
+ : (defaultValue as T | undefined);
56
+ }
57
+ export function hasInjectionContext(): boolean {
58
+ const frame = peekComponentContext();
59
+ return !!frame?.active && !frame.owner.disposed;
60
+ }
61
+ export function useId(): string {
62
+ const frame = getComponentContext();
63
+ let root: Owner = frame.owner;
64
+ while (root.parent) root = root.parent;
65
+ let state = idCounters.get(root);
66
+ if (!state) {
67
+ state = { next: 0 };
68
+ idCounters.set(root, state);
69
+ }
70
+ return `v-${state.next++}`;
71
+ }
@@ -0,0 +1,107 @@
1
+ /** Private callback policy; no Vue app/public-instance ABI. */
2
+ import {
3
+ peekComponentContext,
4
+ setContext,
5
+ withComponentConsumer,
6
+ type ComponentContext,
7
+ } from "@tschk/moonshine-dom/component";
8
+ import { getOwner, runWithOwner, untrack } from "@tschk/moonshine-dom/reactive";
9
+ export type WatchErrorPhase =
10
+ "watch getter" | "watch callback" | "watch effect" | "watch cleanup";
11
+ export type ComponentErrorInfo = {
12
+ readonly component: ComponentContext | undefined;
13
+ readonly phase: WatchErrorPhase;
14
+ };
15
+ export type ComponentErrorHandler = (
16
+ error: unknown,
17
+ info: ComponentErrorInfo,
18
+ ) => void;
19
+ export type ErrorCapturedHook<TError = unknown> = (
20
+ err: TError,
21
+ instance: ComponentContext | undefined,
22
+ info: WatchErrorPhase,
23
+ ) => boolean | void;
24
+ export type ErrorDispatcher = (error: unknown, phase: WatchErrorPhase) => void;
25
+ export const componentErrorKey = /* @__PURE__ */ Symbol(
26
+ "moonshine.vue.callback-error",
27
+ );
28
+ const errorCapturesKey = /* @__PURE__ */ Symbol("moonshine.vue.error-captures");
29
+ type ErrorCaptureLayer = {
30
+ frame: ComponentContext;
31
+ parent?: ErrorCaptureLayer;
32
+ hooks: Array<ErrorCapturedHook<any>>;
33
+ };
34
+ export function registerErrorCaptured(
35
+ frame: ComponentContext,
36
+ hook: ErrorCapturedHook<any>,
37
+ ): void {
38
+ let current = frame.contexts.get(errorCapturesKey) as
39
+ ErrorCaptureLayer | undefined;
40
+ if (current?.frame !== frame) {
41
+ current = { frame, parent: current, hooks: [] };
42
+ setContext(errorCapturesKey, current);
43
+ }
44
+ current.hooks.push(hook);
45
+ }
46
+ export function captureWatchErrorHandler(): ErrorDispatcher | undefined {
47
+ const handler = getOwner()?.context?.get(componentErrorKey) as
48
+ ComponentErrorHandler | undefined;
49
+ const component = peekComponentContext();
50
+ let captures = component?.contexts.get(errorCapturesKey) as
51
+ ErrorCaptureLayer | undefined;
52
+ if (captures && captures.frame === component) captures = captures.parent;
53
+ if (!handler && !captures) return;
54
+ return (error, phase) => {
55
+ let currentError: unknown = error;
56
+ for (let layer = captures; layer; layer = layer.parent) {
57
+ if (layer.frame.owner.disposed) continue;
58
+ for (const hook of layer.hooks.slice()) {
59
+ if (layer.frame.owner.disposed) break;
60
+ let stopPropagation: boolean | void;
61
+ try {
62
+ stopPropagation = runWithOwner(layer.frame.owner, () =>
63
+ untrack(() =>
64
+ withComponentConsumer(layer.frame, () =>
65
+ hook(currentError, component, phase),
66
+ ),
67
+ ),
68
+ );
69
+ } catch (secondary) {
70
+ currentError = secondary;
71
+ continue;
72
+ }
73
+ if (stopPropagation === false) return;
74
+ }
75
+ }
76
+ if (!handler) throw currentError;
77
+ try {
78
+ untrack(() => handler(currentError, { component, phase }));
79
+ } catch (secondary) {
80
+ console.error(secondary);
81
+ }
82
+ };
83
+ }
84
+ export function invokeWatch<T>(
85
+ report: ErrorDispatcher,
86
+ phase: WatchErrorPhase,
87
+ fn: () => T,
88
+ ): T | undefined {
89
+ let result: T;
90
+ try {
91
+ result = fn();
92
+ } catch (error) {
93
+ report(error, phase);
94
+ return;
95
+ }
96
+ // Attach outside the user-call guard: a throwing .catch method must escape.
97
+ if (
98
+ result !== null &&
99
+ (typeof result === "object" || typeof result === "function") &&
100
+ typeof (result as { then?: unknown }).then === "function" &&
101
+ typeof (result as { catch?: unknown }).catch === "function"
102
+ )
103
+ (
104
+ result as unknown as { catch(reject: (error: unknown) => void): unknown }
105
+ ).catch((error) => report(error, phase));
106
+ return result;
107
+ }
package/src/errors.ts ADDED
@@ -0,0 +1,24 @@
1
+ /** Explicit native error scope; does not construct a Vue application. */
2
+ import { createComponentScope, getOwner } from "@tschk/moonshine-dom/reactive";
3
+ import { componentErrorKey, type ComponentErrorHandler } from "./error-context";
4
+ export type {
5
+ ComponentErrorHandler,
6
+ ComponentErrorInfo,
7
+ WatchErrorPhase,
8
+ } from "./error-context";
9
+ export function withComponentErrorHandler<T>(
10
+ handler: ComponentErrorHandler,
11
+ setup: () => T,
12
+ ): T {
13
+ if (typeof handler !== "function" || typeof setup !== "function")
14
+ throw new TypeError("Error handler and setup must be functions");
15
+ const owner = getOwner();
16
+ if (!owner || owner.disposed)
17
+ throw Error("Component error scope requires a live owner");
18
+ return createComponentScope(() => {
19
+ const scope = getOwner()!;
20
+ scope.context = new Map(scope.context);
21
+ scope.context.set(componentErrorKey, handler);
22
+ return setup();
23
+ });
24
+ }
package/src/events.ts ADDED
@@ -0,0 +1,114 @@
1
+ import { getComponentContext } from "@tschk/moonshine-dom/component";
2
+ import {
3
+ errorHandlerKey,
4
+ runWithOwner,
5
+ untrack,
6
+ } from "@tschk/moonshine-dom/reactive";
7
+ type EventMap<E> = { [K in keyof E]: readonly unknown[] };
8
+ type Camel<S extends string> = S extends `${infer A}-${infer B}`
9
+ ? `${A}${Capitalize<Camel<B>>}`
10
+ : S;
11
+ type Listener<A extends readonly unknown[]> = (...args: A) => unknown;
12
+ export type EventListeners<E extends EventMap<E>> = {
13
+ [K in keyof E as K extends string ? `on${Capitalize<Camel<K>>}` : never]?:
14
+ Listener<E[K]> | readonly Listener<E[K]>[];
15
+ } & {
16
+ [
17
+ K in keyof E as K extends string ? `on${Capitalize<Camel<K>>}Once` : never
18
+ ]?: Listener<E[K]> | readonly Listener<E[K]>[];
19
+ };
20
+ export type Emit<E extends EventMap<E>> = <K extends keyof E & string>(
21
+ event: K,
22
+ ...args: E[K]
23
+ ) => void;
24
+ const camel = (name: string) =>
25
+ name.replace(/-(\w)/g, (_, letter: string) => letter.toUpperCase());
26
+ const modifiersOf = (source: object, model: string) => {
27
+ const read = (name: string) =>
28
+ Reflect.get(source, name + "Modifiers", source);
29
+ return model === "modelValue" || model === "model-value"
30
+ ? Reflect.get(source, "modelModifiers", source) ||
31
+ read("modelValue") ||
32
+ read("model-value")
33
+ : read(model) ||
34
+ read(camel(model)) ||
35
+ read(model.replace(/\B([A-Z])/g, "-$1").toLowerCase());
36
+ };
37
+ const key = (name: string) =>
38
+ name ? "on" + name[0]!.toUpperCase() + name.slice(1) : "";
39
+ /** Compiler-private declared component events; no DOM dispatch or Vue app error API. `update:*` emits honor live trim/number modifier flags. */
40
+ export function createEmitter<E extends EventMap<E>>(source: object): Emit<E> {
41
+ const frame = getComponentContext();
42
+ const route = frame.owner.context?.get(errorHandlerKey) as
43
+ ((error: unknown) => boolean) | undefined;
44
+ let emitted: Set<string> | undefined;
45
+ const report = (error: unknown) => {
46
+ if (!route?.(error)) throw error;
47
+ };
48
+ return ((event: string, ...rawArgs: readonly unknown[]) => {
49
+ if (frame.mode === "dom" && frame.owner.disposed) return;
50
+ return untrack(() => {
51
+ let args = rawArgs;
52
+ if (event.startsWith("update:")) {
53
+ const modifiers = modifiersOf(source, event.slice(7)) as
54
+ { trim?: unknown; number?: unknown } | undefined;
55
+ if (modifiers) {
56
+ if (modifiers.trim)
57
+ args = rawArgs.map((value) =>
58
+ typeof value === "string" ? value.trim() : value,
59
+ );
60
+ // Number conversion uses raw arguments even when trim also runs.
61
+ if (modifiers.number)
62
+ args = rawArgs.map((value) => {
63
+ const parsed = parseFloat(value as string);
64
+ return Number.isNaN(parsed) ? value : parsed;
65
+ });
66
+ }
67
+ }
68
+ let name = key(event),
69
+ listener = Reflect.get(source, name, source);
70
+ if (!listener) {
71
+ name = key(camel(event));
72
+ listener = Reflect.get(source, name, source);
73
+ }
74
+ let failed = false,
75
+ failure: unknown;
76
+ const invoke = (value: unknown) => {
77
+ const callbacks = Array.isArray(value) ? value : [value];
78
+ for (const fn of callbacks) {
79
+ if (fn == null) continue;
80
+ try {
81
+ if (typeof fn !== "function")
82
+ throw new TypeError(
83
+ "Component event listeners must be functions",
84
+ );
85
+ const result = Reflect.apply(fn, undefined, args);
86
+ if (
87
+ result &&
88
+ typeof (result as PromiseLike<unknown>).then === "function"
89
+ )
90
+ Promise.resolve(result).then(undefined, (error) => {
91
+ queueMicrotask(() =>
92
+ runWithOwner(frame.owner, () => untrack(() => report(error))),
93
+ );
94
+ });
95
+ } catch (error) {
96
+ try {
97
+ report(error);
98
+ } catch (unrouted) {
99
+ if (!failed) failure = unrouted;
100
+ failed = true;
101
+ }
102
+ }
103
+ }
104
+ };
105
+ invoke(listener);
106
+ const once = Reflect.get(source, name + "Once", source);
107
+ if (once && !emitted?.has(name)) {
108
+ (emitted ??= new Set()).add(name);
109
+ invoke(once);
110
+ }
111
+ if (failed) throw failure;
112
+ });
113
+ }) as Emit<E>;
114
+ }
package/src/expose.ts ADDED
@@ -0,0 +1,123 @@
1
+ import {
2
+ bindOwnedReference,
3
+ enqueueComponentReference,
4
+ type ComponentReference,
5
+ } from "@tschk/moonshine-dom/component-instance";
6
+ import { getOwner } from "@tschk/moonshine-dom/reactive";
7
+ import {
8
+ getTemplateRefBinding,
9
+ isRef,
10
+ unref,
11
+ useTemplateRef,
12
+ type Ref,
13
+ type TemplateRef,
14
+ } from "./reactive";
15
+
16
+ export { useTemplateRef, type TemplateRef };
17
+
18
+ export type ShallowUnwrap<T> = T extends () => infer R
19
+ ? { [K in keyof R]: R[K] extends Readonly<Ref<infer V>> ? V : R[K] }
20
+ : { [K in keyof T]: T[K] extends Readonly<Ref<infer V>> ? V : T[K] };
21
+
22
+ export type TemplateRefBinding<T> =
23
+ | {
24
+ get: () => T | null | undefined;
25
+ set: (value: T | null) => void;
26
+ }
27
+ | Readonly<Ref<T | null>>;
28
+
29
+ function resolveRefBinding<T>(binding: TemplateRefBinding<T>): {
30
+ get: () => T | null | undefined;
31
+ set: (value: T | null) => void;
32
+ } {
33
+ if (isRef(binding)) {
34
+ const internal = getTemplateRefBinding(binding);
35
+ if (internal) return internal;
36
+ return {
37
+ get: () => binding.value,
38
+ set: (value: T | null) => {
39
+ (binding as Ref<T | null>).value = value;
40
+ },
41
+ };
42
+ }
43
+ const accessor = binding as {
44
+ get?: () => T | null | undefined;
45
+ set?: (value: T | null) => void;
46
+ };
47
+ if (
48
+ !accessor ||
49
+ typeof accessor.get !== "function" ||
50
+ typeof accessor.set !== "function"
51
+ )
52
+ throw new TypeError("Template ref binding requires get and set functions");
53
+ return { get: accessor.get, set: accessor.set };
54
+ }
55
+
56
+ /** Wrap a plain defineExpose object so own enumerable keys unwrap and write through refs. */
57
+ export function exposeRefs<T extends object>(source: T): ShallowUnwrap<T> {
58
+ if (
59
+ source === null ||
60
+ typeof source !== "object" ||
61
+ (Object.getPrototypeOf(source) !== Object.prototype &&
62
+ Object.getPrototypeOf(source) !== null)
63
+ )
64
+ throw new TypeError(
65
+ "Component exports must be a plain object of named exports",
66
+ );
67
+ const exposed = Object.create(null) as ShallowUnwrap<T>;
68
+ for (const key of Reflect.ownKeys(source)) {
69
+ if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
70
+ Object.defineProperty(exposed, key, {
71
+ enumerable: true,
72
+ configurable: true,
73
+ get() {
74
+ return unref(Reflect.get(source, key));
75
+ },
76
+ set(next: unknown) {
77
+ const previous = Reflect.get(source, key);
78
+ if (isRef(previous) && !isRef(next)) {
79
+ previous.value = next;
80
+ } else if (!Reflect.set(source, key, next)) {
81
+ throw new TypeError(
82
+ `Cannot assign to read only property '${String(key)}'`,
83
+ );
84
+ }
85
+ },
86
+ });
87
+ }
88
+ return exposed;
89
+ }
90
+
91
+ /** Bind an intrinsic element reference into the shared component reference flush wave. */
92
+ export function bindRef<T extends Element>(
93
+ element: T,
94
+ binding: TemplateRefBinding<T>,
95
+ ): void {
96
+ const owner = getOwner();
97
+ if (!owner || owner.disposed) return;
98
+ const resolved = resolveRefBinding(binding);
99
+ enqueueComponentReference(
100
+ bindOwnedReference(
101
+ owner,
102
+ element,
103
+ {
104
+ cleanup: "commit",
105
+ get: resolved.get,
106
+ set: resolved.set,
107
+ },
108
+ enqueueComponentReference,
109
+ ),
110
+ );
111
+ }
112
+
113
+ /** Create a commit-cleaned component reference binding for a setup ref or useTemplateRef. */
114
+ export function bindComponentRef<T extends object>(
115
+ binding: TemplateRefBinding<T>,
116
+ ): ComponentReference<T> {
117
+ const resolved = resolveRefBinding(binding);
118
+ return {
119
+ cleanup: "commit",
120
+ get: resolved.get,
121
+ set: resolved.set,
122
+ };
123
+ }
@@ -0,0 +1 @@
1
+ export { crepusRenderer } from "@tschk/moonshine-dom/framework-lazy";
package/src/index.ts ADDED
@@ -0,0 +1,42 @@
1
+ /**
2
+ * @tschk/moonshine-vue
3
+ *
4
+ * Independent signal bridges and lazy native SSR compatibility renderer.
5
+ * Legacy Vue runtime/compiler entries are separate from native `/reactive`.
6
+ */
7
+ import {
8
+ createSignal as msCreateSignal,
9
+ type Signal as MsSignal,
10
+ } from "@tschk/moonshine";
11
+
12
+ export type VueRef<T> = {
13
+ get value(): T;
14
+ set value(next: T);
15
+ };
16
+
17
+ export function fromMoonshineSignal<T>(signal: MsSignal<T>): VueRef<T> {
18
+ return {
19
+ get value() {
20
+ return signal();
21
+ },
22
+ set value(next: T) {
23
+ signal.set(() => next);
24
+ },
25
+ };
26
+ }
27
+
28
+ export function createBridgedRef<T>(initial: T): VueRef<T> {
29
+ return fromMoonshineSignal(msCreateSignal(initial));
30
+ }
31
+
32
+ export { msCreateSignal as createMoonshineSignal };
33
+ export type { MsSignal as MoonshineSignal };
34
+ export {
35
+ createResource,
36
+ createSignal as createMsSignal,
37
+ createMemo,
38
+ batch,
39
+ untrack,
40
+ } from "@tschk/moonshine";
41
+ export type { Resource, ResourceStatus } from "@tschk/moonshine";
42
+ export { crepusRenderer } from "./framework";