@viewfly/core 2.1.0 → 3.0.0-alpha.0

package/dist/jsx-runtime/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 供 `jsx: "react-jsx"` + `jsxImportSource: "@viewfly/core"` 使用。
+ * 运行时再导出主包入口，避免把 core 打进本 chunk；`JSX` 与主入口类型一致。
+ * @see https://www.typescriptlang.org/tsconfig#jsxImportSource
+ */
+export { jsx, jsxs, Fragment, jsx as jsxDEV } from '../index';
+export type { JSX } from '../index';

package/dist/jsx-runtime/index.esm.js

@@ -0,0 +1,2 @@
+import { Fragment, jsx, jsx as jsxDEV, jsxs } from "@viewfly/core";
+export { Fragment, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime/index.js

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _viewfly_core = require("@viewfly/core");
+Object.defineProperty(exports, "Fragment", {
+	enumerable: true,
+	get: function() {
+		return _viewfly_core.Fragment;
+	}
+});
+Object.defineProperty(exports, "jsx", {
+	enumerable: true,
+	get: function() {
+		return _viewfly_core.jsx;
+	}
+});
+Object.defineProperty(exports, "jsxDEV", {
+	enumerable: true,
+	get: function() {
+		return _viewfly_core.jsx;
+	}
+});
+Object.defineProperty(exports, "jsxs", {
+	enumerable: true,
+	get: function() {
+		return _viewfly_core.jsxs;
+	}
+});

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 供 `jsx: "react-jsx"` + `jsxImportSource: "@viewfly/core"` 使用。
+ * 运行时再导出主包入口，避免把 core 打进本 chunk；`JSX` 与主入口类型一致。
+ * @see https://www.typescriptlang.org/tsconfig#jsxImportSource
+ */
+export { jsx, jsxs, Fragment, jsx as jsxDEV } from './index.ts';
+export type { JSX } from './index.ts';

package/dist/reactive/_api.d.ts

@@ -0,0 +1,7 @@
+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/_help.d.ts

@@ -0,0 +1,15 @@
+export declare function getStringType(v: any): string;
+export declare function isType(v: any, type: string): boolean;
+export declare function isObject(v: any): v is object;
+export declare function isArray(v: any): v is any[];
+export declare function isMap(v: any): v is Map<any, any>;
+export declare function isWeakMap(v: any): v is WeakMap<any, any>;
+export declare function isSet(v: any): v is Set<any>;
+export declare function isWeakSet(v: any): v is WeakSet<any>;
+export declare function isString(v: any): v is string;
+export declare function isNumber(v: any): v is number;
+export declare function isBoolean(v: any): v is boolean;
+export declare function isNullOrUndefined(v: any): v is (null | undefined);
+export declare function isSymbol(v: any): v is Symbol;
+export declare function isLiteral(v: any): v is string | number | boolean | Symbol | null | undefined;
+export declare function hasOwn(target: any, key: any): boolean;

package/dist/reactive/array-handlers.d.ts

@@ -0,0 +1,30 @@
+export declare function createArrayHandlers(wrapper: (v: unknown) => unknown): {
+    entries(): Generator<unknown[], void, unknown>;
+    keys(): Generator<unknown, void, unknown>;
+    values(): Generator<unknown, void, unknown>;
+    concat(this: any, ...items: any[]): any[];
+    every(this: any, predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: unknown): any;
+    filter(this: any, predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): any;
+    find(predicate: (value: unknown, index: number, obj: unknown[]) => unknown, thisArg?: any): any;
+    findIndex(predicate: (value: unknown, index: number, obj: unknown[]) => unknown, thisArg?: any): number;
+    findLast(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): any;
+    findLastIndex(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): number;
+    forEach(callbackfn: (value: unknown, index: number, array: unknown[]) => void, thisArg?: any): any;
+    includes(...args: unknown[]): boolean;
+    indexOf(...args: unknown[]): number;
+    join(separator?: string): string;
+    lastIndexOf(...args: unknown[]): number;
+    map<U>(callbackFn: (value: unknown, index: number, array: unknown[]) => U, thisArg?: any): U[];
+    pop(): any;
+    push(this: any, ...items: any[]): any;
+    reduce(callbackFn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: unknown[]) => unknown, ...args: any[]): any;
+    reduceRight(callbackFn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: unknown[]) => unknown, ...args: any[]): any;
+    shift(): any;
+    some(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): boolean;
+    splice(start: number, deleteCount?: number): unknown[];
+    toReversed(): any;
+    toSorted(compareFn?: (a: unknown, b: unknown) => number): any;
+    toSpliced(start: number, deleteCount: number, ...items: any[]): any;
+    unshift(...items: any[]): number;
+    [Symbol.iterator](): Generator<unknown, void, unknown>;
+};

package/dist/reactive/computed.d.ts

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

package/dist/reactive/effect.d.ts

@@ -0,0 +1,13 @@
+export declare enum TrackOpTypes {
+    Get = "Get",
+    Has = "Has",
+    Iterate = "Iterate"
+}
+export declare enum TriggerOpTypes {
+    Set = "Set",
+    Add = "Add",
+    Delete = "Delete",
+    Clear = "Clear"
+}
+export declare function track(target: object, type: TrackOpTypes, key?: unknown): void;
+export declare function trigger(target: object, type: TriggerOpTypes, key?: unknown): void;

package/dist/reactive/iterable-iterator.d.ts

@@ -0,0 +1,5 @@
+export declare function createIterableIterator(wrapper: (v: unknown) => unknown): {
+    entries(): Generator<unknown[], void, unknown>;
+    keys(): Generator<unknown, void, unknown>;
+    values(): Generator<unknown, void, unknown>;
+};

package/dist/reactive/map-handlers.d.ts

@@ -0,0 +1,12 @@
+export declare function createMapHandlers(wrapper: (v: unknown) => unknown): {
+    entries(): Generator<unknown[], void, unknown>;
+    keys(): Generator<unknown, void, unknown>;
+    values(): Generator<unknown, void, unknown>;
+    get(this: any, key: any): unknown;
+    set(this: any, key: any, value: any): Map<any, any>;
+    has(this: any, key: any): any;
+    delete(this: any, key: any): any;
+    forEach(this: any, callbackFn: (value: any, key: any, map: Map<any, any>) => void, thisArg?: any): void;
+    clear(this: any): void;
+    [Symbol.iterator](): Generator<unknown[], void, unknown>;
+};

package/dist/reactive/reactive.d.ts

@@ -0,0 +1,141 @@
+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;
+    protected isReadonly: boolean;
+    constructor(config: ReactiveConfig);
+    set(target: T, p: string | symbol, newValue: any, receiver: any): boolean;
+    get(target: T, p: string | symbol, receiver: any): any;
+    deleteProperty(target: T, p: string | symbol): boolean;
+    ownKeys(target: T): ArrayLike<string | symbol>;
+}
+export declare class ArrayReactiveHandler extends ObjectReactiveHandler<any[]> {
+    interceptors: {
+        entries(): Generator<unknown[], void, unknown>;
+        keys(): Generator<unknown, void, unknown>;
+        values(): Generator<unknown, void, unknown>;
+        concat(this: any, ...items: any[]): any[];
+        every(this: any, predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: unknown): any;
+        filter(this: any, predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): any;
+        find(predicate: (value: unknown, index: number, obj: unknown[]) => unknown, thisArg?: any): any;
+        findIndex(predicate: (value: unknown, index: number, obj: unknown[]) => unknown, thisArg?: any): number;
+        findLast(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): any;
+        findLastIndex(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): number;
+        forEach(callbackfn: (value: unknown, index: number, array: unknown[]) => void, thisArg?: any): any;
+        includes(...args: unknown[]): boolean;
+        indexOf(...args: unknown[]): number;
+        join(separator?: string): string;
+        lastIndexOf(...args: unknown[]): number;
+        map<U>(callbackFn: (value: unknown, index: number, array: unknown[]) => U, thisArg?: any): U[];
+        pop(): any;
+        push(this: any, ...items: any[]): any;
+        reduce(callbackFn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: unknown[]) => unknown, ...args: any[]): any;
+        reduceRight(callbackFn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: unknown[]) => unknown, ...args: any[]): any;
+        shift(): any;
+        some(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): boolean;
+        splice(start: number, deleteCount?: number): unknown[];
+        toReversed(): any;
+        toSorted(compareFn?: (a: unknown, b: unknown) => number): any;
+        toSpliced(start: number, deleteCount: number, ...items: any[]): any;
+        unshift(...items: any[]): number;
+        [Symbol.iterator](): Generator<unknown, void, unknown>;
+    };
+    constructor(config: ReactiveConfig);
+    get(target: any[], p: string | symbol, receiver: any): any;
+}
+export declare class MapReactiveHandler extends ObjectReactiveHandler<Map<any, any> | WeakMap<object, any>> {
+    interceptors: {
+        entries(): Generator<unknown[], void, unknown>;
+        keys(): Generator<unknown, void, unknown>;
+        values(): Generator<unknown, void, unknown>;
+        get(this: any, key: any): unknown;
+        set(this: any, key: any, value: any): Map<any, any>;
+        has(this: any, key: any): any;
+        delete(this: any, key: any): any;
+        forEach(this: any, callbackFn: (value: any, key: any, map: Map<any, any>) => void, thisArg?: any): void;
+        clear(this: any): void;
+        [Symbol.iterator](): Generator<unknown[], void, unknown>;
+    };
+    constructor(config: ReactiveConfig);
+    get(target: Map<any, any> | WeakMap<object, any>, p: string | symbol, receiver: any): any;
+}
+export declare class SetReactiveHandler extends ObjectReactiveHandler<Set<any> | WeakSet<object>> {
+    interceptors: {
+        entries(): Generator<unknown[], void, unknown>;
+        keys(): Generator<unknown, void, unknown>;
+        values(): Generator<unknown, void, unknown>;
+        add(this: any, value: any): any;
+        delete(this: any, value: any): any;
+        has(this: any, key: any): any;
+        forEach(this: any, callbackFn: (value: any, value2: any, set: Set<any>) => void, thisArg?: any): void;
+        clear(this: any): void;
+        [Symbol.iterator](): Generator<unknown, void, unknown>;
+    };
+    constructor(config: ReactiveConfig);
+    get(target: Set<any> | WeakSet<object>, p: string | symbol, receiver: any): any;
+}
+export declare const defaultObjectReactiveHandler: ObjectReactiveHandler<object>;
+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/set-handlers.d.ts

@@ -0,0 +1,11 @@
+export declare function createSetHandlers(wrapper: (v: unknown) => unknown): {
+    entries(): Generator<unknown[], void, unknown>;
+    keys(): Generator<unknown, void, unknown>;
+    values(): Generator<unknown, void, unknown>;
+    add(this: any, value: any): any;
+    delete(this: any, value: any): any;
+    has(this: any, key: any): any;
+    forEach(this: any, callbackFn: (value: any, value2: any, set: Set<any>) => void, thisArg?: any): void;
+    clear(this: any): void;
+    [Symbol.iterator](): Generator<unknown, void, unknown>;
+};

package/dist/reactive/shallow-reactive.d.ts

@@ -0,0 +1,6 @@
+import { ArrayReactiveHandler, MapReactiveHandler, ObjectReactiveHandler, SetReactiveHandler } from './reactive';
+export declare const defaultShallowObjectReactiveHandler: ObjectReactiveHandler<object>;
+export declare const defaultShallowArrayReactiveHandler: ArrayReactiveHandler;
+export declare const defaultShallowMapReactiveHandler: MapReactiveHandler;
+export declare const defaultShallowSetReactiveHandler: SetReactiveHandler;
+export declare function shallowReactive<T>(raw: T): T;

package/dist/reactive/signal.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 组件状态实例，直接调用可以获取最新的状态，通过 set 方法可以更新状态
+ */
+export interface Signal<T> {
+    /**
+     *  直接调用一个 Signal 实例，可以获取最新状态
+     */
+    (): T;
+    /**
+     * 更新组件状态的方法，可以传入最新的值
+     * @param newState
+     */
+    set(newState: T): void;
+}
+/**
+ * 组件状态管理器
+ * @param state 初始状态
+ * @example
+ * ```tsx
+ * function App() {
+ *   // 初始化状态
+ *   const state = createSignal(1)
+ *
+ *   return () => {
+ *     <div>
+ *       <div>当前值为：{state()}</div>
+ *       <div>
+ *         <button type="button" onClick={() => {
+ *           // 当点击时更新状态
+ *           state.set(state() + 1)
+ *         }
+ *         }>updateState</button>
+ *       </div>
+ *     </div>
+ *   }
+ * }
+ */
+export declare function createSignal<T>(state: T): Signal<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

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

package/dist/viewfly.d.ts

@@ -0,0 +1,30 @@
+import { Provider, Injector } from './di/_api';
+import { ElementNamespace, JSXNode, NativeNode, NativeRenderer } from './base/_api';
+/**
+ * Viewfly 配置项
+ */
+export interface Config {
+    /** 根节点 */
+    root: JSXNode;
+    /** 平台渲染器 */
+    nativeRenderer: NativeRenderer;
+    /** 应用的上下文 */
+    context?: Injector;
+    /** 是否自动更新视图 */
+    autoUpdate?: boolean;
+    /** 根节点命名空间 */
+    elementNamespace?: ElementNamespace;
+}
+export interface Application<T extends NativeNode = NativeNode> {
+    provide(providers: Provider | Provider[]): Application<T>;
+    mount(host: T): Application<T>;
+    use(module: Module | Module[]): Application<T>;
+    render(): Application<T>;
+    destroy(): void;
+}
+export interface Module {
+    setup?(app: Application): void;
+    onAfterStartup?(app: Application): void;
+    onDestroy?(): void;
+}
+export declare function viewfly<T extends NativeNode>(config: Config): Application<T>;

package/package.json

@@ -1,43 +1,38 @@
 {
   "name": "@viewfly/core",
-  "version": "2.1.0",
+  "version": "3.0.0-alpha.0",
   "description": "Viewfly is a simple and easy-to-use JavaScript framework with an intuitive development experience.",
-  "main": "./bundles/index.js",
-  "module": "./bundles/index.esm.js",
-  "typings": "./bundles/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.esm.js",
+  "typings": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./bundles/index.d.ts",
-      "import": "./bundles/index.esm.js",
-      "require": "./bundles/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.js"
     },
     "./jsx-runtime": {
-      "types": "./jsx-runtime/index.d.ts",
-      "import": "./jsx-runtime/index.esm.js",
-      "require": "./jsx-runtime/index.js"
+      "types": "./dist/jsx-runtime/index.d.ts",
+      "import": "./dist/jsx-runtime/index.esm.js",
+      "require": "./dist/jsx-runtime/index.js"
     },
     "./jsx-dev-runtime": {
-      "types": "./jsx-runtime/index.d.ts",
-      "import": "./jsx-runtime/index.esm.js",
-      "require": "./jsx-runtime/index.js"
+      "types": "./dist/jsx-runtime/index.d.ts",
+      "import": "./dist/jsx-runtime/index.esm.js",
+      "require": "./dist/jsx-runtime/index.js"
     }
   },
-  "scripts": {
-    "build:lib": "rimraf bundles && npm run build  && npm run build-d",
-    "build": "rollup --config rollup.config.ts --configPlugin @rollup/plugin-typescript",
-    "build-d": "rollup --config rollup-d.config.ts --configPlugin @rollup/plugin-typescript",
-    "publish:lib": "npm run build:lib && npm publish --access=public"
-  },
+  "files": [
+    "dist/**/*"
+  ],
   "license": "MIT",
   "keywords": [],
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^25.0.3",
-    "@rollup/plugin-replace": "^5.0.2",
-    "@rollup/plugin-typescript": "^11.1.2",
-    "rimraf": "^3.0.2",
-    "rollup": "^3.26.3",
-    "rollup-plugin-dts": "^6.1.1",
-    "tslib": "^2.6.0"
+    "rimraf": "^6.0.1",
+    "tslib": "^2.8.1",
+    "typescript": "~5.8.3",
+    "vite": "^8.0.9",
+    "vite-plugin-dts": "^4.5.4"
   },
   "author": {
     "name": "Tanbo",
@@ -48,10 +43,15 @@
     "url": "git+https://github.com/viewfly/viewfly.git"
   },
   "bugs": {
-    "url": "https://github.com/viewfly/viewfly.git/issues"
+    "url": "https://github.com/viewfly/viewfly/issues"
   },
-  "gitHead": "b66ca589f7662cd518fc2e5955b3e3ff9de83f94",
   "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"
   }
-}
+}