@viewfly/core 2.2.0 → 3.0.0-alpha.0

package/dist/reactive/_api.d.ts

@@ -2,4 +2,6 @@ export * from './computed';
 export * from './effect';
 export * from './reactive';
 export * from './shallow-reactive';
+export * from './signal';
 export * from './watch';
+export * from './watch-effect';

package/dist/reactive/computed.d.ts

@@ -1,4 +1,10 @@
 export interface Computed<T> {
     readonly value: T;
 }
-export declare function computed<T>(callback: () => T, isContinue?: (data: T) => unknown): Computed<T>;
+/**
+ * 创建一个 computed，当依赖的值发生变化时，会重新计算值。
+ * computed 会返回一个对象，对象的 value 属性是计算的值。
+ * @param getter 计算函数，用于计算值
+ * @returns 一个对象，对象的 value 属性是计算的值
+ */
+export declare function computed<T>(getter: () => T): Computed<T>;

package/dist/reactive/reactive.d.ts

@@ -1,11 +1,42 @@
 export declare const rawToProxyCache: WeakMap<object, any>;
 export declare const proxyToRawCache: WeakMap<object, any>;
+/**
+ * 将响应式对象转换为原始对象
+ * @param value 响应式对象
+ * @returns 原始对象
+ * @example
+ * ```tsx
+ * const obj = reactive({
+ *   name: 'John',
+ *   age: 18
+ * })
+ * console.log(toRaw(obj))
+ * ```
+ */
 export declare function toRaw<T>(value: T): T;
+/**
+ * 检查对象是否是响应式对象
+ * @param value 要检查的对象
+ * @returns 是否是响应式对象
+ * @example
+ * ```tsx
+ * const obj = reactive({
+ *   name: 'John',
+ *   age: 18
+ * })
+ * console.log(isReactive(obj))
+ * ```
+ */
 export declare function isReactive(value: any): boolean;
 export interface ReactiveConfig {
     readonly: boolean;
     shallow: boolean;
 }
+/**
+ * 内部写入，用于避免类型为只读的响应式对象写入报错
+ * @param fn 要执行的函数
+ * @internal
+ */
 export declare function internalWrite(fn: () => void): void;
 export declare class ObjectReactiveHandler<T extends object> implements ProxyHandler<T> {
     protected isShallow: boolean;
@@ -86,4 +117,25 @@ export declare const defaultArrayReactiveHandler: ArrayReactiveHandler;
 export declare const defaultMapReactiveHandler: MapReactiveHandler;
 export declare const defaultSetReactiveHandler: SetReactiveHandler;
 export declare const readonlyProxyHandler: ObjectReactiveHandler<object>;
+export declare function createShallowReadonlyProxy<T extends object>(value: T): Readonly<T>;
+/**
+ * 创建一个响应式对象
+ * @param raw 原始对象
+ * @returns 响应式对象
+ * @example
+ * ```tsx
+ * const obj = reactive({
+ *   name: 'John',
+ *   age: 18,
+ *   children: [
+ *     {
+ *       name: 'Jane',
+ *       age: 16
+ *     }
+ *   ]
+ * })
+ * console.log(obj.name)
+ * console.log(obj.children[0].name)
+ * ```
+ */
 export declare function reactive<T>(raw: T): T;

package/dist/reactive/watch-effect.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 创建一个 watchEffect，立即执行 effect 函数，当依赖的值发生变化时，会再次执行 effect 函数。
+ * watchEffect 会返回一个函数，用于停止监听
+ * @param effect 执行的函数
+ * @returns 一个函数，用于停止监听
+ */
+export declare function watchEffect(effect: () => void): () => void;

package/dist/reactive/watch.d.ts

@@ -1 +1,8 @@
-export declare function watch<T>(trigger: () => T, callback: (newValue: T, oldValue: T) => (() => any) | void): () => void;
+/**
+ * 创建一个 watch，当依赖的值发生变化时，会执行 callback 函数。
+ * watch 会返回一个函数，用于停止监听。
+ * @param trigger 触发函数，用于获取依赖的值
+ * @param callback 回调函数，当依赖的值发生变化时，会执行 callback 函数
+ * @returns 一个函数，用于停止监听
+ */
+export declare function watch<T>(trigger: () => T, callback: (newValue: T, oldValue: T) => void): () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viewfly/core",
-  "version": "2.2.0",
+  "version": "3.0.0-alpha.0",
   "description": "Viewfly is a simple and easy-to-use JavaScript framework with an intuitive development experience.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",
@@ -22,12 +22,6 @@
       "require": "./dist/jsx-runtime/index.js"
     }
   },
-  "scripts": {
-    "build:lib": "rimraf dist && pnpm run build && pnpm run build:jsx-runtime",
-    "build": "vite build --config vite.config.ts",
-    "build:jsx-runtime": "vite build --config vite.jsx-runtime.config.ts",
-    "publish:lib": "npm run build:lib && npm publish --access=public"
-  },
   "files": [
     "dist/**/*"
   ],
@@ -53,5 +47,11 @@
   },
   "dependencies": {
     "reflect-metadata": "^0.2.2"
+  },
+  "scripts": {
+    "build:lib": "rimraf dist && pnpm run build && pnpm run build:jsx-runtime",
+    "build": "vite build --config vite.config.ts",
+    "build:jsx-runtime": "vite build --config vite.jsx-runtime.config.ts",
+    "publish:lib": "npm run build:lib && npm publish --access=public"
   }
-}
+}

package/dist/base/memo.d.ts

@@ -1,8 +0,0 @@
-import { Props } from './jsx-element';
-import { ComponentInstance, JSXNode } from './component';
-/**
- * @deprecated 即将弃用，Viewfly 默认就有 memo 的效果
- * @param canUseMemo
- * @param render
- */
-export declare function withMemo<T extends Props = Props>(canUseMemo: ComponentInstance<T>['$useMemo'], render: () => JSXNode): ComponentInstance<T>;

package/dist/signals/_api.d.ts

@@ -1,3 +0,0 @@
-export * from './derived';
-export * from './effect';
-export * from './signal';

package/dist/signals/derived.d.ts

@@ -1,9 +0,0 @@
-import { Signal } from './signal';
-/**
- * 使用派生值，Viewfly 会收集回调函数内同步执行时访问的 Signal，
- * 并在你获取 createDerived 函数返回的 Signal 的值时，自动计算最新的值。
- *
- * @param fn
- * @param isContinue 可选的停止函数，在每次值更新后调用，当返回值为 false 时，将不再监听依赖的变化
- */
-export declare function createDerived<T>(fn: () => T, isContinue?: (data: T) => unknown): Signal<T>;

package/dist/signals/effect.d.ts

@@ -1,22 +0,0 @@
-import { Signal } from './signal';
-export interface EffectCallback<T> {
-    (newValue: T, oldValue: T): void | (() => void);
-}
-/**
- * 监听状态变化，当任意一个状态发生变更时，触发回调。
- * createEffect 会返回一个取消监听的函数，调用此函数，可以取消监听。
- * 当在组件中调用时，组件销毁时会自动取消监听。
- * @param deps 依赖的状态 Signal，可以是一个 Signal，只可以一个数包含 Signal 的数组，或者是一个求值函数
- * @param callback 状态变更后的回调函数
- */
-export declare function createEffect<T>(deps: Signal<T>, callback: EffectCallback<T>): () => void;
-export declare function createEffect<T>(deps: [Signal<T>], callback: EffectCallback<[T]>): () => void;
-export declare function createEffect<T, T1>(deps: [Signal<T>, Signal<T1>], callback: EffectCallback<[T, T1]>): () => void;
-export declare function createEffect<T, T1, T2>(deps: [Signal<T>, Signal<T1>, Signal<T2>], callback: EffectCallback<[T, T1, T2]>): () => void;
-export declare function createEffect<T, T1, T2, T3>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>], callback: EffectCallback<[T, T1, T2, T3]>): () => void;
-export declare function createEffect<T, T1, T2, T3, T4>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>, Signal<T4>], callback: EffectCallback<[T, T1, T2, T3, T4]>): () => void;
-export declare function createEffect<T, T1, T2, T3, T4, T5>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>, Signal<T4>, Signal<T5>], callback: EffectCallback<[T, T1, T2, T3, T4, T5]>): () => void;
-export declare function createEffect<T, T1, T2, T3, T4, T5, T6>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>, Signal<T4>, Signal<T5>, Signal<T6>], callback: EffectCallback<[T, T1, T2, T3, T4, T5, T6]>): () => void;
-export declare function createEffect<T, T1, T2, T3, T4, T5, T6, T7>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>, Signal<T4>, Signal<T5>, Signal<T6>, Signal<T7>], callback: EffectCallback<[T, T1, T2, T3, T4, T5, T6, T7]>): () => void;
-export declare function createEffect<T>(deps: () => T, callback: EffectCallback<T>): () => void;
-export declare function createEffect<T = any>(deps: Signal<any>[], callback: EffectCallback<T[]>): () => void;