@pyreon/preact-compat 0.5.5 → 0.5.7
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/lib/types/hooks.d.ts +44 -175
- package/lib/types/hooks.d.ts.map +1 -1
- package/lib/types/jsx-runtime.d.ts +7 -84
- package/lib/types/jsx-runtime.d.ts.map +1 -1
- package/lib/types/signals.d.ts +30 -52
- package/lib/types/signals.d.ts.map +1 -1
- package/package.json +4 -4
package/lib/types/hooks.d.ts
CHANGED
|
@@ -1,178 +1,47 @@
|
|
|
1
|
-
import { onErrorCaptured, useContext } from "@pyreon/core";
|
|
2
|
-
function getCurrentCtx() {
|
|
3
|
-
return _currentCtx;
|
|
4
|
-
}
|
|
5
|
-
function getHookIndex() {
|
|
6
|
-
return _hookIndex++;
|
|
7
|
-
}
|
|
8
|
-
|
|
9
|
-
//#endregion
|
|
10
|
-
//#region src/hooks.ts
|
|
11
|
-
function requireCtx() {
|
|
12
|
-
const ctx = getCurrentCtx();
|
|
13
|
-
if (!ctx) throw new Error("Hook called outside of a component render");
|
|
14
|
-
return ctx;
|
|
15
|
-
}
|
|
16
|
-
function depsChanged(a, b) {
|
|
17
|
-
if (a === void 0 || b === void 0) return true;
|
|
18
|
-
if (a.length !== b.length) return true;
|
|
19
|
-
for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return true;
|
|
20
|
-
return false;
|
|
21
|
-
}
|
|
22
|
-
/**
|
|
23
|
-
* Preact-compatible `useState` — returns `[value, setter]`.
|
|
24
|
-
* Triggers a component re-render when the setter is called.
|
|
25
|
-
*/
|
|
26
|
-
function useState(initial) {
|
|
27
|
-
const ctx = requireCtx();
|
|
28
|
-
const idx = getHookIndex();
|
|
29
|
-
if (ctx.hooks.length <= idx) ctx.hooks.push(typeof initial === "function" ? initial() : initial);
|
|
30
|
-
const value = ctx.hooks[idx];
|
|
31
|
-
const setter = v => {
|
|
32
|
-
const current = ctx.hooks[idx];
|
|
33
|
-
const next = typeof v === "function" ? v(current) : v;
|
|
34
|
-
if (Object.is(current, next)) return;
|
|
35
|
-
ctx.hooks[idx] = next;
|
|
36
|
-
ctx.scheduleRerender();
|
|
37
|
-
};
|
|
38
|
-
return [value, setter];
|
|
39
|
-
}
|
|
40
|
-
/**
|
|
41
|
-
* Preact-compatible `useEffect` — runs after render when deps change.
|
|
42
|
-
* Returns cleanup on unmount and before re-running.
|
|
43
|
-
*/
|
|
44
|
-
function useEffect(fn, deps) {
|
|
45
|
-
const ctx = requireCtx();
|
|
46
|
-
const idx = getHookIndex();
|
|
47
|
-
if (ctx.hooks.length <= idx) {
|
|
48
|
-
const entry = {
|
|
49
|
-
fn,
|
|
50
|
-
deps,
|
|
51
|
-
cleanup: void 0
|
|
52
|
-
};
|
|
53
|
-
ctx.hooks.push(entry);
|
|
54
|
-
ctx.pendingEffects.push(entry);
|
|
55
|
-
} else {
|
|
56
|
-
const entry = ctx.hooks[idx];
|
|
57
|
-
if (depsChanged(entry.deps, deps)) {
|
|
58
|
-
entry.fn = fn;
|
|
59
|
-
entry.deps = deps;
|
|
60
|
-
ctx.pendingEffects.push(entry);
|
|
61
|
-
}
|
|
62
|
-
}
|
|
63
|
-
}
|
|
64
|
-
/**
|
|
65
|
-
* Preact-compatible `useLayoutEffect` — runs synchronously after DOM mutations.
|
|
66
|
-
*/
|
|
67
|
-
function useLayoutEffect(fn, deps) {
|
|
68
|
-
const ctx = requireCtx();
|
|
69
|
-
const idx = getHookIndex();
|
|
70
|
-
if (ctx.hooks.length <= idx) {
|
|
71
|
-
const entry = {
|
|
72
|
-
fn,
|
|
73
|
-
deps,
|
|
74
|
-
cleanup: void 0
|
|
75
|
-
};
|
|
76
|
-
ctx.hooks.push(entry);
|
|
77
|
-
ctx.pendingLayoutEffects.push(entry);
|
|
78
|
-
} else {
|
|
79
|
-
const entry = ctx.hooks[idx];
|
|
80
|
-
if (depsChanged(entry.deps, deps)) {
|
|
81
|
-
entry.fn = fn;
|
|
82
|
-
entry.deps = deps;
|
|
83
|
-
ctx.pendingLayoutEffects.push(entry);
|
|
84
|
-
}
|
|
85
|
-
}
|
|
86
|
-
}
|
|
87
|
-
/**
|
|
88
|
-
* Preact-compatible `useMemo` — returns the cached value, recomputed when deps change.
|
|
89
|
-
*/
|
|
90
|
-
function useMemo(fn, deps) {
|
|
91
|
-
const ctx = requireCtx();
|
|
92
|
-
const idx = getHookIndex();
|
|
93
|
-
if (ctx.hooks.length <= idx) {
|
|
94
|
-
const value = fn();
|
|
95
|
-
ctx.hooks.push({
|
|
96
|
-
value,
|
|
97
|
-
deps
|
|
98
|
-
});
|
|
99
|
-
return value;
|
|
100
|
-
}
|
|
101
|
-
const entry = ctx.hooks[idx];
|
|
102
|
-
if (depsChanged(entry.deps, deps)) {
|
|
103
|
-
entry.value = fn();
|
|
104
|
-
entry.deps = deps;
|
|
105
|
-
}
|
|
106
|
-
return entry.value;
|
|
107
|
-
}
|
|
108
|
-
/**
|
|
109
|
-
* Preact-compatible `useCallback` — returns the cached function when deps haven't changed.
|
|
110
|
-
*/
|
|
111
|
-
function useCallback(fn, deps) {
|
|
112
|
-
return useMemo(() => fn, deps);
|
|
113
|
-
}
|
|
114
|
-
/**
|
|
115
|
-
* Preact-compatible `useRef` — returns `{ current }` persisted across re-renders.
|
|
116
|
-
*/
|
|
117
|
-
function useRef(initial) {
|
|
118
|
-
const ctx = requireCtx();
|
|
119
|
-
const idx = getHookIndex();
|
|
120
|
-
if (ctx.hooks.length <= idx) {
|
|
121
|
-
const ref = {
|
|
122
|
-
current: initial !== void 0 ? initial : null
|
|
123
|
-
};
|
|
124
|
-
ctx.hooks.push(ref);
|
|
125
|
-
}
|
|
126
|
-
return ctx.hooks[idx];
|
|
127
|
-
}
|
|
128
|
-
/**
|
|
129
|
-
* Preact-compatible `useReducer` — returns `[state, dispatch]`.
|
|
130
|
-
*/
|
|
131
|
-
function useReducer(reducer, initial) {
|
|
132
|
-
const ctx = requireCtx();
|
|
133
|
-
const idx = getHookIndex();
|
|
134
|
-
if (ctx.hooks.length <= idx) ctx.hooks.push(typeof initial === "function" ? initial() : initial);
|
|
135
|
-
const state = ctx.hooks[idx];
|
|
136
|
-
const dispatch = action => {
|
|
137
|
-
const current = ctx.hooks[idx];
|
|
138
|
-
const next = reducer(current, action);
|
|
139
|
-
if (Object.is(current, next)) return;
|
|
140
|
-
ctx.hooks[idx] = next;
|
|
141
|
-
ctx.scheduleRerender();
|
|
142
|
-
};
|
|
143
|
-
return [state, dispatch];
|
|
144
|
-
}
|
|
145
|
-
/**
|
|
146
|
-
* Preact-compatible `useId` — returns a stable unique string per hook call.
|
|
147
|
-
*/
|
|
148
|
-
function useId() {
|
|
149
|
-
const ctx = requireCtx();
|
|
150
|
-
const idx = getHookIndex();
|
|
151
|
-
if (ctx.hooks.length <= idx) ctx.hooks.push(`:r${(_idCounter++).toString(36)}:`);
|
|
152
|
-
return ctx.hooks[idx];
|
|
153
|
-
}
|
|
154
|
-
/**
|
|
155
|
-
* Preact-compatible `memo` — wraps a component to skip re-render when props
|
|
156
|
-
* are shallowly equal.
|
|
157
|
-
*/
|
|
158
|
-
function memo(component, areEqual) {
|
|
159
|
-
const compare = areEqual ?? ((a, b) => {
|
|
160
|
-
const keysA = Object.keys(a);
|
|
161
|
-
const keysB = Object.keys(b);
|
|
162
|
-
if (keysA.length !== keysB.length) return false;
|
|
163
|
-
for (const k of keysA) if (!Object.is(a[k], b[k])) return false;
|
|
164
|
-
return true;
|
|
165
|
-
});
|
|
166
|
-
let prevProps = null;
|
|
167
|
-
let prevResult = null;
|
|
168
|
-
return props => {
|
|
169
|
-
if (prevProps !== null && compare(prevProps, props)) return prevResult;
|
|
170
|
-
prevProps = props;
|
|
171
|
-
prevResult = component(props);
|
|
172
|
-
return prevResult;
|
|
173
|
-
};
|
|
174
|
-
}
|
|
1
|
+
import { VNodeChild, onErrorCaptured, useContext } from "@pyreon/core";
|
|
175
2
|
|
|
3
|
+
//#region src/hooks.d.ts
|
|
4
|
+
/**
|
|
5
|
+
* Preact-compatible `useState` — returns `[value, setter]`.
|
|
6
|
+
* Triggers a component re-render when the setter is called.
|
|
7
|
+
*/
|
|
8
|
+
declare function useState<T>(initial: T | (() => T)): [T, (v: T | ((prev: T) => T)) => void];
|
|
9
|
+
/**
|
|
10
|
+
* Preact-compatible `useEffect` — runs after render when deps change.
|
|
11
|
+
* Returns cleanup on unmount and before re-running.
|
|
12
|
+
*/
|
|
13
|
+
declare function useEffect(fn: () => (() => void) | void, deps?: unknown[]): void;
|
|
14
|
+
/**
|
|
15
|
+
* Preact-compatible `useLayoutEffect` — runs synchronously after DOM mutations.
|
|
16
|
+
*/
|
|
17
|
+
declare function useLayoutEffect(fn: () => (() => void) | void, deps?: unknown[]): void;
|
|
18
|
+
/**
|
|
19
|
+
* Preact-compatible `useMemo` — returns the cached value, recomputed when deps change.
|
|
20
|
+
*/
|
|
21
|
+
declare function useMemo<T>(fn: () => T, deps: unknown[]): T;
|
|
22
|
+
/**
|
|
23
|
+
* Preact-compatible `useCallback` — returns the cached function when deps haven't changed.
|
|
24
|
+
*/
|
|
25
|
+
declare function useCallback<T extends (...args: never[]) => unknown>(fn: T, deps: unknown[]): T;
|
|
26
|
+
/**
|
|
27
|
+
* Preact-compatible `useRef` — returns `{ current }` persisted across re-renders.
|
|
28
|
+
*/
|
|
29
|
+
declare function useRef<T>(initial?: T): {
|
|
30
|
+
current: T | null;
|
|
31
|
+
};
|
|
32
|
+
/**
|
|
33
|
+
* Preact-compatible `useReducer` — returns `[state, dispatch]`.
|
|
34
|
+
*/
|
|
35
|
+
declare function useReducer<S, A>(reducer: (state: S, action: A) => S, initial: S | (() => S)): [S, (action: A) => void];
|
|
36
|
+
/**
|
|
37
|
+
* Preact-compatible `useId` — returns a stable unique string per hook call.
|
|
38
|
+
*/
|
|
39
|
+
declare function useId(): string;
|
|
40
|
+
/**
|
|
41
|
+
* Preact-compatible `memo` — wraps a component to skip re-render when props
|
|
42
|
+
* are shallowly equal.
|
|
43
|
+
*/
|
|
44
|
+
declare function memo<P extends Record<string, unknown>>(component: (props: P) => VNodeChild, areEqual?: (prevProps: P, nextProps: P) => boolean): (props: P) => VNodeChild;
|
|
176
45
|
//#endregion
|
|
177
46
|
export { memo, useCallback, useContext, useEffect, onErrorCaptured as useErrorBoundary, useId, useLayoutEffect, useMemo, useReducer, useRef, useState };
|
|
178
|
-
//# sourceMappingURL=
|
|
47
|
+
//# sourceMappingURL=hooks2.d.ts.map
|
package/lib/types/hooks.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"
|
|
1
|
+
{"version":3,"file":"hooks2.d.ts","names":[],"sources":["../../../src/hooks.ts"],"mappings":";;;;;;;iBAwCgB,QAAA,GAAA,CAAY,OAAA,EAAS,CAAA,UAAW,CAAA,KAAM,CAAA,GAAI,CAAA,EAAG,CAAA,KAAM,IAAA,EAAM,CAAA,KAAM,CAAA;;;;;iBA2B/D,SAAA,CAAU,EAAA,6BAA+B,IAAA;;;;iBAyBzC,eAAA,CAAgB,EAAA,6BAA+B,IAAA;AAzB/D;;;AAAA,iBAgDgB,OAAA,GAAA,CAAW,EAAA,QAAU,CAAA,EAAG,IAAA,cAAkB,CAAA;;AAvB1D;;iBA8CgB,WAAA,eAA0B,IAAA,sBAAA,CAA2B,EAAA,EAAI,CAAA,EAAG,IAAA,cAAkB,CAAA;;;AAvB9F;iBAgCgB,MAAA,GAAA,CAAU,OAAA,GAAU,CAAA;EAAM,OAAA,EAAS,CAAA;AAAA;;;;iBAiBnC,UAAA,MAAA,CACd,OAAA,GAAU,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,KAAM,CAAA,EAClC,OAAA,EAAS,CAAA,UAAW,CAAA,KAClB,CAAA,GAAI,MAAA,EAAQ,CAAA;;;;iBA2BA,KAAA,CAAA;;;;;iBAiBA,IAAA,WAAe,MAAA,kBAAA,CAC7B,SAAA,GAAY,KAAA,EAAO,CAAA,KAAM,UAAA,EACzB,QAAA,IAAY,SAAA,EAAW,CAAA,EAAG,SAAA,EAAW,CAAA,gBACnC,KAAA,EAAO,CAAA,KAAM,UAAA"}
|
|
@@ -1,87 +1,10 @@
|
|
|
1
|
-
import { Fragment,
|
|
2
|
-
import { signal } from "@pyreon/reactivity";
|
|
1
|
+
import { ComponentFn, Fragment, Props, VNode, VNodeChild } from "@pyreon/core";
|
|
3
2
|
|
|
4
|
-
//#region src/jsx-runtime.ts
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
ctx.pendingEffects = [];
|
|
10
|
-
ctx.pendingLayoutEffects = [];
|
|
11
|
-
}
|
|
12
|
-
function endRender() {
|
|
13
|
-
_currentCtx = null;
|
|
14
|
-
_hookIndex = 0;
|
|
15
|
-
}
|
|
16
|
-
function runLayoutEffects(entries) {
|
|
17
|
-
for (const entry of entries) {
|
|
18
|
-
if (entry.cleanup) entry.cleanup();
|
|
19
|
-
const cleanup = entry.fn();
|
|
20
|
-
entry.cleanup = typeof cleanup === "function" ? cleanup : void 0;
|
|
21
|
-
}
|
|
22
|
-
}
|
|
23
|
-
function scheduleEffects(ctx, entries) {
|
|
24
|
-
if (entries.length === 0) return;
|
|
25
|
-
queueMicrotask(() => {
|
|
26
|
-
for (const entry of entries) {
|
|
27
|
-
if (ctx.unmounted) return;
|
|
28
|
-
if (entry.cleanup) entry.cleanup();
|
|
29
|
-
const cleanup = entry.fn();
|
|
30
|
-
entry.cleanup = typeof cleanup === "function" ? cleanup : void 0;
|
|
31
|
-
}
|
|
32
|
-
});
|
|
33
|
-
}
|
|
34
|
-
function wrapCompatComponent(preactComponent) {
|
|
35
|
-
let wrapped = _wrapperCache.get(preactComponent);
|
|
36
|
-
if (wrapped) return wrapped;
|
|
37
|
-
wrapped = props => {
|
|
38
|
-
const ctx = {
|
|
39
|
-
hooks: [],
|
|
40
|
-
scheduleRerender: () => {},
|
|
41
|
-
pendingEffects: [],
|
|
42
|
-
pendingLayoutEffects: [],
|
|
43
|
-
unmounted: false
|
|
44
|
-
};
|
|
45
|
-
const version = signal(0);
|
|
46
|
-
let updateScheduled = false;
|
|
47
|
-
ctx.scheduleRerender = () => {
|
|
48
|
-
if (ctx.unmounted || updateScheduled) return;
|
|
49
|
-
updateScheduled = true;
|
|
50
|
-
queueMicrotask(() => {
|
|
51
|
-
updateScheduled = false;
|
|
52
|
-
if (!ctx.unmounted) version.set(version.peek() + 1);
|
|
53
|
-
});
|
|
54
|
-
};
|
|
55
|
-
return () => {
|
|
56
|
-
version();
|
|
57
|
-
beginRender(ctx);
|
|
58
|
-
const result = preactComponent(props);
|
|
59
|
-
const layoutEffects = ctx.pendingLayoutEffects;
|
|
60
|
-
const effects = ctx.pendingEffects;
|
|
61
|
-
endRender();
|
|
62
|
-
runLayoutEffects(layoutEffects);
|
|
63
|
-
scheduleEffects(ctx, effects);
|
|
64
|
-
return result;
|
|
65
|
-
};
|
|
66
|
-
};
|
|
67
|
-
_wrapperCache.set(preactComponent, wrapped);
|
|
68
|
-
return wrapped;
|
|
69
|
-
}
|
|
70
|
-
function jsx(type, props, key) {
|
|
71
|
-
const {
|
|
72
|
-
children,
|
|
73
|
-
...rest
|
|
74
|
-
} = props;
|
|
75
|
-
const propsWithKey = key != null ? {
|
|
76
|
-
...rest,
|
|
77
|
-
key
|
|
78
|
-
} : rest;
|
|
79
|
-
if (typeof type === "function") return h(wrapCompatComponent(type), children !== void 0 ? {
|
|
80
|
-
...propsWithKey,
|
|
81
|
-
children
|
|
82
|
-
} : propsWithKey);
|
|
83
|
-
return h(type, propsWithKey, ...(children === void 0 ? [] : Array.isArray(children) ? children : [children]));
|
|
84
|
-
}
|
|
3
|
+
//#region src/jsx-runtime.d.ts
|
|
4
|
+
declare function jsx(type: string | ComponentFn | symbol, props: Props & {
|
|
5
|
+
children?: VNodeChild | VNodeChild[];
|
|
6
|
+
}, key?: string | number | null): VNode;
|
|
7
|
+
declare const jsxs: typeof jsx;
|
|
85
8
|
//#endregion
|
|
86
9
|
export { Fragment, jsx, jsxs };
|
|
87
|
-
//# sourceMappingURL=jsx-
|
|
10
|
+
//# sourceMappingURL=jsx-runtime2.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"jsx-
|
|
1
|
+
{"version":3,"file":"jsx-runtime2.d.ts","names":[],"sources":["../../../src/jsx-runtime.ts"],"mappings":";;;iBA2IgB,GAAA,CACd,IAAA,WAAe,WAAA,WACf,KAAA,EAAO,KAAA;EAAU,QAAA,GAAW,UAAA,GAAa,UAAA;AAAA,GACzC,GAAA,4BACC,KAAA;AAAA,cAiBU,IAAA,SAAI,GAAA"}
|
package/lib/types/signals.d.ts
CHANGED
|
@@ -1,57 +1,35 @@
|
|
|
1
|
-
import { batch as pyreonBatch
|
|
1
|
+
import { batch as pyreonBatch } from "@pyreon/reactivity";
|
|
2
2
|
|
|
3
|
-
//#region src/signals.ts
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
* @example
|
|
8
|
-
* const count = signal(0)
|
|
9
|
-
* count.value++ // write
|
|
10
|
-
* console.log(count.value) // read (tracked)
|
|
11
|
-
*/
|
|
12
|
-
function signal(initial) {
|
|
13
|
-
const s = signal$1(initial);
|
|
14
|
-
return {
|
|
15
|
-
get value() {
|
|
16
|
-
return s();
|
|
17
|
-
},
|
|
18
|
-
set value(v) {
|
|
19
|
-
s.set(v);
|
|
20
|
-
},
|
|
21
|
-
peek() {
|
|
22
|
-
return s.peek();
|
|
23
|
-
}
|
|
24
|
-
};
|
|
3
|
+
//#region src/signals.d.ts
|
|
4
|
+
interface ReadonlySignal<T> {
|
|
5
|
+
readonly value: T;
|
|
6
|
+
peek(): T;
|
|
25
7
|
}
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
*
|
|
29
|
-
* @example
|
|
30
|
-
* const doubled = computed(() => count.value * 2)
|
|
31
|
-
* console.log(doubled.value)
|
|
32
|
-
*/
|
|
33
|
-
function computed(fn) {
|
|
34
|
-
const c = computed$1(fn);
|
|
35
|
-
return {
|
|
36
|
-
get value() {
|
|
37
|
-
return c();
|
|
38
|
-
},
|
|
39
|
-
peek() {
|
|
40
|
-
return c();
|
|
41
|
-
}
|
|
42
|
-
};
|
|
8
|
+
interface WritableSignal<T> extends ReadonlySignal<T> {
|
|
9
|
+
value: T;
|
|
43
10
|
}
|
|
44
11
|
/**
|
|
45
|
-
*
|
|
46
|
-
*
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
12
|
+
* Create a Preact-style signal with `.value` accessor.
|
|
13
|
+
*
|
|
14
|
+
* @example
|
|
15
|
+
* const count = signal(0)
|
|
16
|
+
* count.value++ // write
|
|
17
|
+
* console.log(count.value) // read (tracked)
|
|
18
|
+
*/
|
|
19
|
+
declare function signal<T>(initial: T): WritableSignal<T>;
|
|
20
|
+
/**
|
|
21
|
+
* Create a Preact-style computed with `.value` accessor.
|
|
22
|
+
*
|
|
23
|
+
* @example
|
|
24
|
+
* const doubled = computed(() => count.value * 2)
|
|
25
|
+
* console.log(doubled.value)
|
|
26
|
+
*/
|
|
27
|
+
declare function computed<T>(fn: () => T): ReadonlySignal<T>;
|
|
28
|
+
/**
|
|
29
|
+
* Run a side-effect that auto-tracks signal reads.
|
|
30
|
+
* Returns a dispose function.
|
|
31
|
+
*/
|
|
32
|
+
declare function effect(fn: () => void | (() => void)): () => void;
|
|
55
33
|
//#endregion
|
|
56
|
-
export { pyreonBatch as batch, computed, effect, signal };
|
|
57
|
-
//# sourceMappingURL=
|
|
34
|
+
export { ReadonlySignal, WritableSignal, pyreonBatch as batch, computed, effect, signal };
|
|
35
|
+
//# sourceMappingURL=signals2.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"
|
|
1
|
+
{"version":3,"file":"signals2.d.ts","names":[],"sources":["../../../src/signals.ts"],"mappings":";;;UAiBiB,cAAA;EAAA,SACN,KAAA,EAAO,CAAA;EAChB,IAAA,IAAQ,CAAA;AAAA;AAAA,UAGO,cAAA,YAA0B,cAAA,CAAe,CAAA;EACxD,KAAA,EAAO,CAAA;AAAA;AADT;;;;;;;;AAAA,iBAYgB,MAAA,GAAA,CAAU,OAAA,EAAS,CAAA,GAAI,cAAA,CAAe,CAAA;;;;;;;AAAtD;iBAwBgB,QAAA,GAAA,CAAY,EAAA,QAAU,CAAA,GAAI,cAAA,CAAe,CAAA;;;;;iBAoBzC,MAAA,CAAO,EAAA"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@pyreon/preact-compat",
|
|
3
|
-
"version": "0.5.
|
|
3
|
+
"version": "0.5.7",
|
|
4
4
|
"description": "Preact-compatible API shim for Pyreon — write Preact-style code that runs on Pyreon's reactive engine",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"repository": {
|
|
@@ -59,9 +59,9 @@
|
|
|
59
59
|
"prepublishOnly": "bun run build"
|
|
60
60
|
},
|
|
61
61
|
"dependencies": {
|
|
62
|
-
"@pyreon/core": "^0.5.
|
|
63
|
-
"@pyreon/reactivity": "^0.5.
|
|
64
|
-
"@pyreon/runtime-dom": "^0.5.
|
|
62
|
+
"@pyreon/core": "^0.5.7",
|
|
63
|
+
"@pyreon/reactivity": "^0.5.7",
|
|
64
|
+
"@pyreon/runtime-dom": "^0.5.7"
|
|
65
65
|
},
|
|
66
66
|
"devDependencies": {
|
|
67
67
|
"@happy-dom/global-registrator": "^20.8.3",
|