mobx-react-use-autorun 1.0.1

package/.vscode/settings.json

@@ -0,0 +1,13 @@
+{
+    "files.exclude": {
+        ".gitignore": true,
+        "package-lock.json": true,
+        "tsconfig.json": true,
+        ".vscode": true,
+        "bin": true,
+        "dist": true,
+        "coverage": true,
+        "babel.config.js": true,
+        "jest.config.ts": true,
+    }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Robert Taussig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# Getting Started with Create React App
+
+This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app). If you have any questions, please contact zdu.strong@gmail.com.<br/>
+
+## Development environment setup
+1. From https://code.visualstudio.com install Visual Studio Code.<br/>
+2. From https://nodejs.org/en/ install nodejs v16.<br/>
+
+## Available Scripts
+
+In the project directory, you can run:<br/>
+
+### `npm test`
+
+Run all unit tests.<br/>
+See the section about [running tests](https://www.cypress.io) for more information.<br/>
+
+### `npm run build`
+
+Builds the app for production to the `build` folder.<br/>
+It correctly bundles React in production mode and optimizes the build for the best performance.<br/>
+
+The build is minified and the filenames include the hashes.<br/>
+Your app is ready to be deployed!<br/>
+
+See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.<br/>
+
+### `npm run push`
+
+Publish to npm repository
+
+## Notes - Define state with useLocalObservable
+
+    import { useLocalObservable, observer } from 'mobx-react-use-autorun';
+
+    export default observer(() => {
+
+        const state = useLocalObservable(() => ({ randomNumber: 1 }));
+
+        return <div onClick={() => state.randomNumber = Math.random()}>
+            {state.randomNumber}
+        </div>
+    })
+
+more usage:<br/>
+表单验证<br/>
+
+    import { Button, TextField } from '@mui/material';
+    import { observer, useLocalObservable } from 'mobx-react-use-autorun';
+    import { MessageService } from '../../common/MessageService';
+
+    export default observer(() => {
+
+        const state = useLocalObservable(() => ({
+            name: "",
+            submit: false,
+            errors: {
+                get name() {
+                    return state.submit && !state.name && "请填写名称";
+                },
+                get hasError() {
+                    return state.errors.name;
+                }
+            }
+        }));
+
+        const ok = async () => {
+            state.submit = true;
+            if (state.errors.hasError) {
+                MessageService.error("错误");
+            } else {
+                MessageService.success("提交成功");
+            }
+        }
+
+        return (<div className='flex flex-col' style={{ padding: "2em" }}>
+            <TextField value={state.name} label="用户名" onChange={(e) => state.name = e.target.value} error={!!state.errors.name} helperText={state.errors.name} />
+            <Button variant="contained" style={{ marginTop: "2em" }} onClick={ok} >提交</Button>
+        </div>)
+    })
+
+## Notes - Using props and other hooks with useAsLocalSource
+
+    import { observer, useAsLocalSource } from 'mobx-react-use-autorun';
+    import { useLocation } from 'react-router-dom';
+
+    export default observer((props: { name: string }) => {
+
+        const source = useAsLocalSource({ location: useLocation(), ...props });
+
+        return <div>
+            {source.name}
+            {source.location.pathname}
+        </div>
+    })
+
+## Notes - Subscription property changes with useAutorun
+
+    import { useLocalObservable, observer, useAutorun, toJS } from 'mobx-react-use-autorun';
+
+    export default observer(() => {
+
+        const state = useLocalObservable(() => ({ randomNumber: 1 }));
+
+        useAutorun(() => {
+            console.log(toJS(state))
+        }, [state]);
+
+        return <div onClick={() => state.randomNumber = Math.random()}>
+            {state.randomNumber}
+        </div>
+    })
+
+## Notes - Define global mutable data
+
+    import { observable } from 'mobx-react-use-autorun';
+
+    const state = observable({});
+
+## Notes - Define a delayed promise with timeout
+
+    import { timeout } form 'mobx-react-use-autorun';
+
+    async function(){
+        await timeout(100);
+        await timeout(new Date());
+    }
+
+## Notes - Get the real data of the proxy object with toJS
+
+    import { observable, toJS } from 'mobx-react-use-autorun';
+
+    const state = observable({});
+    console.log(toJS(state));
+
+## Learn More
+
+1. React UI framework (https://reactjs.org)<br/>
+2. React hooks (https://www.npmjs.com/package/react-use)<br/>

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    presets: [
+        ['@babel/preset-env', { targets: { node: 'current' } }],
+        '@babel/preset-typescript',
+    ],
+};

package/bin/mobx_react_build.ts

@@ -0,0 +1,29 @@
+import { execSync } from "child_process";
+import path from 'path';
+
+const run = async () => {
+    execSync(
+        [
+            "cross-env",
+            "TS_NODE_SKIP_PROJECT=true",
+            "ts-node bin/pre_load_configuration.ts",
+        ].join(" "),
+
+        {
+            stdio: "inherit",
+            cwd: path.join(__dirname, ".."),
+        }
+    );
+    execSync(
+        [
+            "cross-env",
+            "tsc -p .",
+        ].join(" "),
+        {
+            stdio: "inherit",
+            cwd: path.join(__dirname, ".."),
+        }
+    );
+};
+
+export default run();

package/bin/mobx_react_test.ts

@@ -0,0 +1,27 @@
+import { execSync } from "child_process";
+import path from 'path';
+
+const run = async () => {
+    execSync(
+        [
+            "cross-env",
+            "TS_NODE_SKIP_PROJECT=true",
+            "ts-node bin/pre_load_configuration.ts",
+        ].join(" "),
+        {
+            stdio: "inherit",
+            cwd: path.join(__dirname, ".."),
+        }
+    );
+    execSync(
+        [
+            "jest --verbose --no-cache",
+        ].join(" "),
+        {
+            stdio: "inherit",
+            cwd: path.join(__dirname, ".."),
+        }
+    );
+};
+
+export default run();

package/bin/pre_load_configuration.ts

@@ -0,0 +1,30 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+const run = async () => {
+    await deletePackageLockFile();
+    await deleteBuildFolder();
+    execSync(
+        [
+            "cross-env",
+            "npm_config_package_lock=false",
+            "npm install",
+        ].join(" "),
+        {
+            stdio: "inherit",
+        }
+    );
+};
+
+const deletePackageLockFile = async () => {
+    const filePathOfPackageLockFile = path.join(__dirname, "..", "package-lock.json");
+    await fs.promises.rm(filePathOfPackageLockFile, { recursive: true, force: true });
+};
+
+const deleteBuildFolder = async () => {
+    const folderPath = path.join(__dirname, "..", "dist");
+    await fs.promises.rm(folderPath, { recursive: true, force: true });
+};
+
+export default run();

package/jest.config.ts

@@ -0,0 +1,195 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+export default {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "C:\\Users\\zdu\\AppData\\Local\\Temp\\jest",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "\\\\node_modules\\\\"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  // coverageProvider: "babel",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  testEnvironment: "jsdom",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "\\\\node_modules\\\\"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "\\\\node_modules\\\\",
+  //   "\\.pnp\\.[^\\\\]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "mobx-react-use-autorun",
+  "version": "1.0.1",
+  "description": "React Hook for mobx",
+  "scripts": {
+    "build": "npm install -g typescript@4.6.3 @types/node@17.0.23 ts-node@10.7.0 cross-env@7.0.3 && cross-env TS_NODE_SKIP_PROJECT=true ts-node bin/mobx_react_build.ts",
+    "test": "npm install -g typescript@4.6.3 @types/node@17.0.23 ts-node@10.7.0 cross-env@7.0.3 && cross-env TS_NODE_SKIP_PROJECT=true ts-node bin/mobx_react_test.ts",
+    "push": "npm test npm run build && npm publish"
+  },
+  "main": "./dist/index.js",
+  "eslintConfig": {
+    "extends": [
+      "react-app"
+    ]
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  },
+  "devDependencies": {
+    "@babel/core": "7.17.10",
+    "@babel/preset-env": "7.17.10",
+    "@babel/preset-typescript": "7.16.7",
+    "@testing-library/react-hooks": "8.0.0",
+    "@types/jest": "27.5.0",
+    "@types/node": "17.0.23",
+    "@types/react": "17.0.44",
+    "babel-jest": "28.0.3",
+    "get-port": "5.1.1",
+    "jest": "28.0.3",
+    "jest-environment-jsdom": "28.0.2",
+    "mobx": "6.5.0",
+    "mobx-react-lite": "3.3.0",
+    "react": "17.0.2",
+    "react-dom": "17.0.2",
+    "react-use": "17.3.2",
+    "rxjs": "7.5.5",
+    "rxjs-exhaustmap-with-trailing": "2.0.0",
+    "tree-kill": "1.2.2",
+    "ts-node": "10.7.0",
+    "typescript": "4.6.3",
+    "wait-on": "6.0.1"
+  }
+}

package/src/index.tsx

@@ -0,0 +1,13 @@
+import './lib/mobx_config'
+import { toJS, observable } from 'mobx';
+import { useLocalObservable, observer } from 'mobx-react-lite';
+import { timeout } from './lib/timeout'
+import { useAsLocalSource } from './lib/useAsLocalSource';
+import { useAutorun } from './lib/useAutorun';
+import { useAsyncExhaust } from './lib/useAsyncExhaust';
+
+export { toJS, observable, observer, useLocalObservable }
+export { timeout }
+export { useAsLocalSource }
+export { useAutorun }
+export { useAsyncExhaust }

package/src/lib/mobx_config.tsx

@@ -0,0 +1,5 @@
+import { configure } from 'mobx';
+
+configure({
+    enforceActions: "never"
+})

package/src/lib/timeout.tsx

@@ -0,0 +1,5 @@
+import { lastValueFrom, timer } from 'rxjs';
+
+export async function timeout(due: number | Date) {
+    await lastValueFrom(timer(due));
+}

package/src/lib/useAsLocalSource.tsx

@@ -0,0 +1,22 @@
+import './mobx_config'
+import { toJS } from 'mobx';
+import { useRef } from 'react';
+
+export function useAsLocalSource<T extends object>(data: T): T {
+
+    const initStateCallback = () => {
+        if (Array.isArray(data)) {
+            throw new Error('Arrays is unsupported!');
+        }
+        const initState = {} as T;
+        return initState;
+    };
+
+    const state = useRef(initStateCallback());
+
+    for (const key in data) {
+        state.current[key] = toJS(data[key]);
+    }
+
+    return state.current;
+};

package/src/lib/useAsyncExhaust.tsx

@@ -0,0 +1,98 @@
+import './mobx_config'
+import { toJS } from 'mobx';
+import { useLocalObservable } from 'mobx-react-lite';
+import { useMount, useUnmount } from 'react-use';
+import { catchError, concatMap, debounceTime, EMPTY, from, lastValueFrom, ReplaySubject, Subscription } from 'rxjs';
+import { exhaustMapWithTrailing } from 'rxjs-exhaustmap-with-trailing';
+import { useAsLocalSource } from './useAsLocalSource';
+
+export function useAsyncExhaust<T>(callback: T) {
+
+    const runCallback: any = function () {
+        if (state.isUnmount) {
+            const resultSubjectPromise = Promise.reject(new Error("Cancelled!"));
+            resultSubjectPromise.catch(() => null);
+            return resultSubjectPromise;
+        } else {
+            const resultSubject = new ReplaySubject(0);
+            const resultSubjectPromise = lastValueFrom(resultSubject);
+            state.resultSubjectList.push({
+                subject: resultSubject,
+                promise: resultSubjectPromise
+            });
+            state.subject.next({
+                params: arguments
+            });
+            return resultSubjectPromise;
+        }
+    }
+
+    const state = useLocalObservable(() => {
+        return {
+            subscription: new Subscription(),
+            subject: new ReplaySubject(0),
+            resultSubjectList: [] as {
+                subject: ReplaySubject<any>,
+                promise: Promise<any>,
+            }[],
+            isUnmount: false,
+        };
+    })
+
+    const source: { callback: any } = useAsLocalSource({
+        callback
+    })
+
+    useMount(() => {
+        state.subscription.add(state.subject.pipe(
+            debounceTime(0),
+            exhaustMapWithTrailing(({ params }: any) => {
+                const resultSubjectList = toJS(state.resultSubjectList);
+                return from((async () => { return await source.callback(...params) })()).pipe(
+                    concatMap((result) => {
+                        for (const resultSubject of resultSubjectList) {
+                            resultSubject.subject.next(result);
+                            resultSubject.subject.complete();
+                            if (resultSubject.subject.closed) {
+                                const index = state.resultSubjectList.findIndex(s => s === resultSubject);
+                                if (index >= 0) {
+                                    state.resultSubjectList.splice(index, 1);
+                                }
+                            }
+                        }
+                        return EMPTY;
+                    }),
+                    catchError((error) => {
+                        for (const resultSubject of resultSubjectList) {
+                            resultSubject.subject.error(error);
+                            if (resultSubject.subject.closed) {
+                                const index = state.resultSubjectList.findIndex(s => s === resultSubject);
+                                if (index >= 0) {
+                                    state.resultSubjectList.splice(index, 1);
+                                }
+                            }
+                        }
+                        return EMPTY;
+                    })
+                );
+            }),
+        ).subscribe());
+    })
+
+    useUnmount(() => {
+        state.subscription.unsubscribe();
+        state.isUnmount = true;
+        for (const resultSubject of toJS(state.resultSubjectList)) {
+            resultSubject.promise.catch(() => null);
+            resultSubject.subject.error(new Error("Cancelled!"));
+            if (resultSubject.subject.closed) {
+                const index = state.resultSubjectList.findIndex(s => s === resultSubject);
+                if (index >= 0) {
+                    state.resultSubjectList.splice(index, 1);
+                }
+            }
+        }
+    })
+
+    return runCallback as T;
+}

package/src/lib/useAutorun.tsx

@@ -0,0 +1,35 @@
+import './mobx_config'
+import { useLocalObservable } from 'mobx-react-lite';
+import { useMount, useUnmount } from 'react-use';
+import { catchError, distinctUntilChanged, ReplaySubject, Subscription, tap } from 'rxjs';
+import { useEffect } from 'react';
+import { useAsLocalSource } from './useAsLocalSource';
+
+export const useAutorun = (callback: () => void, dependencyList: any[]): void => {
+    const state = useLocalObservable(() => ({
+        subscription: new Subscription(),
+        subject: new ReplaySubject(1),
+    }))
+
+    const source = useAsLocalSource({
+        callback
+    })
+
+    useEffect(() => {
+        state.subject.next(JSON.stringify(dependencyList));
+    })
+
+    useMount(() => {
+        state.subscription.add(state.subject.pipe(
+            distinctUntilChanged(),
+            tap(() => {
+                source.callback();
+            }),
+            catchError((_, caught) => caught),
+        ).subscribe());
+    })
+
+    useUnmount(() => {
+        state.subscription.unsubscribe();
+    })
+}

package/test/timeout.test.tsx

@@ -0,0 +1,12 @@
+import { timeout } from '../src/index'
+
+let startDate = null as Date | null;
+
+test('Expect timeout as a promise to return after one second', async () => {
+    await timeout(1000)
+    expect(new Date().getTime()).toBeGreaterThanOrEqual(startDate.getTime())
+})
+
+beforeAll(() => {
+    startDate = new Date();
+})

package/test/use-as-local-source.test.tsx

@@ -0,0 +1,9 @@
+import { useAsLocalSource } from '../src/index'
+import { renderHook } from '@testing-library/react-hooks'
+
+test('Expect useAsLocalSource to return the passed in value', () => {
+    const { result } = renderHook((props) => useAsLocalSource(props), {
+        initialProps: { people: { name: 'tom' } }
+    });
+    expect(result.current.people.name).toEqual('tom')
+})

package/test/use-async-exhaust.test.tsx

@@ -0,0 +1,18 @@
+import { useAsyncExhaust, timeout } from '../src/index'
+import { renderHook } from '@testing-library/react-hooks'
+
+test('Expect useAsyncExhaust to run only once when it is called consecutively', async () => {
+    let runTimes = 0;
+    const { result } = renderHook(() => useAsyncExhaust(async () => {
+        await timeout(1000);
+        runTimes++;
+    }));
+    await Promise.all([
+        result.current(),
+        result.current(),
+        result.current(),
+        result.current(),
+        result.current(),
+    ])
+    expect(runTimes).toEqual(1)
+})

package/test/use-autorun.test.tsx

@@ -0,0 +1,17 @@
+import { useAutorun } from '../src/index'
+import { renderHook } from '@testing-library/react-hooks'
+
+test('Expect useAutorun to take effect', () => {
+  let runTimes = 0;
+  const { rerender } = renderHook((props) => useAutorun(() => {
+    runTimes++;
+  }, [props.people]), {
+    initialProps: { people: { name: 'tom', age: 16 } }
+  });
+  expect(runTimes).toEqual(1)
+  rerender({ people: { name: 'tom', age: 16 } })
+  expect(runTimes).toEqual(1)
+  rerender({ people: { name: 'tom', age: 17 } })
+  rerender({ people: { name: 'tom', age: 18 } })
+  expect(runTimes).toEqual(3)
+})

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist/",
+    "target": "es5",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": false,
+    "jsx": "react-jsx",
+    "sourceMap": true,
+    "declaration": true,
+  },
+  "include": [
+    "src",
+  ]
+}