Updated package.json, readme.md and added theme.toml.
This commit is contained in:
Jeremy Nusser
parent
35fa6f7266
commit
9776a9d1e3
|
|
@ -0,0 +1 @@
|
|||
node_modules/
|
||||
|
|
@ -35,4 +35,11 @@ Has paginated Categories and Tags. Markdown files will automatically convert ima
|
|||
|
||||
<a href="https://www.buymeacoffee.com/nusserstudios" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-blue.png" alt="Buy Me A Coffee" height="41" width="174"></a>
|
||||
|
||||
## Credits
|
||||
4044ever - Original Theme
|
||||
https://github.com/4044ever/Hugo-Tailwind-3.0.git
|
||||
|
||||
Jan Heise - Alpine.js Navbar
|
||||
https://github.com/jan-heise/responsive-navbar-with-dropdown
|
||||
|
||||
Made for Hacktoberfest, with ❤️ by NusserStudios.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 3.8 MiB |
|
|
@ -1 +0,0 @@
|
|||
../acorn/bin/acorn
|
||||
|
|
@ -1 +0,0 @@
|
|||
../autoprefixer/bin/autoprefixer
|
||||
|
|
@ -1 +0,0 @@
|
|||
../browserslist/cli.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../update-browserslist-db/cli.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../concurrently/dist/bin/concurrently.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../concurrently/dist/bin/concurrently.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../cssesc/bin/cssesc
|
||||
|
|
@ -1 +0,0 @@
|
|||
../detective/bin/detective.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../nanoid/bin/nanoid.cjs
|
||||
|
|
@ -1 +0,0 @@
|
|||
../postcss-cli/index.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../resolve/bin/resolve
|
||||
|
|
@ -1 +0,0 @@
|
|||
../tailwindcss/lib/cli.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../tailwindcss/lib/cli.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../tree-kill/cli.js
|
||||
|
|
@ -1,168 +0,0 @@
|
|||
{
|
||||
"systemParams": "linux-x64-93",
|
||||
"modulesFolders": [
|
||||
"node_modules"
|
||||
],
|
||||
"flags": [],
|
||||
"linkedModules": [],
|
||||
"topLevelPatterns": [
|
||||
"@tailwindcss/typography@^0.5.7",
|
||||
"alpinejs@^3.10.5",
|
||||
"autoprefixer@^10.4.12",
|
||||
"concurrently@^7.4.0",
|
||||
"postcss-cli@^10.0.0",
|
||||
"postcss@^8.4.18",
|
||||
"tailwindcss@^3.2.1"
|
||||
],
|
||||
"lockfileEntries": {
|
||||
"@nodelib/fs.scandir@2.1.5": "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5",
|
||||
"@nodelib/fs.stat@2.0.5": "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b",
|
||||
"@nodelib/fs.stat@^2.0.2": "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b",
|
||||
"@nodelib/fs.walk@^1.2.3": "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a",
|
||||
"@tailwindcss/typography@^0.5.7": "https://registry.yarnpkg.com/@tailwindcss/typography/-/typography-0.5.7.tgz#e0b95bea787ee14c5a34a74fc824e6fe86ea8855",
|
||||
"@vue/reactivity@~3.1.1": "https://registry.yarnpkg.com/@vue/reactivity/-/reactivity-3.1.5.tgz#dbec4d9557f7c8f25c2635db1e23a78a729eb991",
|
||||
"@vue/shared@3.1.5": "https://registry.yarnpkg.com/@vue/shared/-/shared-3.1.5.tgz#74ee3aad995d0a3996a6bb9533d4d280514ede03",
|
||||
"acorn-node@^1.8.2": "https://registry.yarnpkg.com/acorn-node/-/acorn-node-1.8.2.tgz#114c95d64539e53dede23de8b9d96df7c7ae2af8",
|
||||
"acorn-walk@^7.0.0": "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-7.2.0.tgz#0de889a601203909b0fbe07b8938dc21d2e967bc",
|
||||
"acorn@^7.0.0": "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa",
|
||||
"alpinejs@^3.10.5": "https://registry.yarnpkg.com/alpinejs/-/alpinejs-3.10.5.tgz#59ca09ad42293cc8e0bbbdf4c7696fc22c6df700",
|
||||
"ansi-regex@^5.0.1": "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304",
|
||||
"ansi-styles@^4.0.0": "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937",
|
||||
"ansi-styles@^4.1.0": "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937",
|
||||
"anymatch@~3.1.2": "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.2.tgz#c0557c096af32f106198f4f4e2a383537e378716",
|
||||
"arg@^5.0.2": "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c",
|
||||
"autoprefixer@^10.4.12": "https://registry.yarnpkg.com/autoprefixer/-/autoprefixer-10.4.12.tgz#183f30bf0b0722af54ee5ef257f7d4320bb33129",
|
||||
"binary-extensions@^2.0.0": "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d",
|
||||
"braces@^3.0.2": "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107",
|
||||
"braces@~3.0.2": "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107",
|
||||
"browserslist@^4.21.4": "https://registry.yarnpkg.com/browserslist/-/browserslist-4.21.4.tgz#e7496bbc67b9e39dd0f98565feccdcb0d4ff6987",
|
||||
"camelcase-css@^2.0.1": "https://registry.yarnpkg.com/camelcase-css/-/camelcase-css-2.0.1.tgz#ee978f6947914cc30c6b44741b6ed1df7f043fd5",
|
||||
"caniuse-lite@^1.0.30001400": "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001422.tgz#f2d7c6202c49a8359e6e35add894d88ef93edba1",
|
||||
"caniuse-lite@^1.0.30001407": "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001422.tgz#f2d7c6202c49a8359e6e35add894d88ef93edba1",
|
||||
"chalk@^4.1.0": "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01",
|
||||
"chokidar@^3.3.0": "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.3.tgz#1cf37c8707b932bd1af1ae22c0432e2acd1903bd",
|
||||
"chokidar@^3.5.3": "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.3.tgz#1cf37c8707b932bd1af1ae22c0432e2acd1903bd",
|
||||
"cliui@^8.0.1": "https://registry.yarnpkg.com/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa",
|
||||
"color-convert@^2.0.1": "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3",
|
||||
"color-name@^1.1.4": "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2",
|
||||
"color-name@~1.1.4": "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2",
|
||||
"concurrently@^7.4.0": "https://registry.yarnpkg.com/concurrently/-/concurrently-7.4.0.tgz#bb0e344964bc172673577c420db21e963f2f7368",
|
||||
"cssesc@^3.0.0": "https://registry.yarnpkg.com/cssesc/-/cssesc-3.0.0.tgz#37741919903b868565e1c09ea747445cd18983ee",
|
||||
"date-fns@^2.29.1": "https://registry.yarnpkg.com/date-fns/-/date-fns-2.29.3.tgz#27402d2fc67eb442b511b70bbdf98e6411cd68a8",
|
||||
"defined@^1.0.0": "https://registry.yarnpkg.com/defined/-/defined-1.0.1.tgz#c0b9db27bfaffd95d6f61399419b893df0f91ebf",
|
||||
"dependency-graph@^0.11.0": "https://registry.yarnpkg.com/dependency-graph/-/dependency-graph-0.11.0.tgz#ac0ce7ed68a54da22165a85e97a01d53f5eb2e27",
|
||||
"detective@^5.2.1": "https://registry.yarnpkg.com/detective/-/detective-5.2.1.tgz#6af01eeda11015acb0e73f933242b70f24f91034",
|
||||
"didyoumean@^1.2.2": "https://registry.yarnpkg.com/didyoumean/-/didyoumean-1.2.2.tgz#989346ffe9e839b4555ecf5666edea0d3e8ad037",
|
||||
"dir-glob@^3.0.1": "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f",
|
||||
"dlv@^1.1.3": "https://registry.yarnpkg.com/dlv/-/dlv-1.1.3.tgz#5c198a8a11453596e751494d49874bc7732f2e79",
|
||||
"electron-to-chromium@^1.4.251": "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.284.tgz#61046d1e4cab3a25238f6bf7413795270f125592",
|
||||
"emoji-regex@^8.0.0": "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37",
|
||||
"escalade@^3.1.1": "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40",
|
||||
"fast-glob@^3.2.11": "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80",
|
||||
"fast-glob@^3.2.12": "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80",
|
||||
"fastq@^1.6.0": "https://registry.yarnpkg.com/fastq/-/fastq-1.13.0.tgz#616760f88a7526bdfc596b7cab8c18938c36b98c",
|
||||
"fill-range@^7.0.1": "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40",
|
||||
"fraction.js@^4.2.0": "https://registry.yarnpkg.com/fraction.js/-/fraction.js-4.2.0.tgz#448e5109a313a3527f5a3ab2119ec4cf0e0e2950",
|
||||
"fs-extra@^10.0.0": "https://registry.yarnpkg.com/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf",
|
||||
"fsevents@~2.3.2": "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a",
|
||||
"function-bind@^1.1.1": "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d",
|
||||
"get-caller-file@^2.0.5": "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e",
|
||||
"get-stdin@^9.0.0": "https://registry.yarnpkg.com/get-stdin/-/get-stdin-9.0.0.tgz#3983ff82e03d56f1b2ea0d3e60325f39d703a575",
|
||||
"glob-parent@^5.1.2": "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4",
|
||||
"glob-parent@^6.0.2": "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3",
|
||||
"glob-parent@~5.1.2": "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4",
|
||||
"globby@^13.0.0": "https://registry.yarnpkg.com/globby/-/globby-13.1.2.tgz#29047105582427ab6eca4f905200667b056da515",
|
||||
"graceful-fs@^4.1.6": "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c",
|
||||
"graceful-fs@^4.2.0": "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c",
|
||||
"has-flag@^4.0.0": "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b",
|
||||
"has@^1.0.3": "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796",
|
||||
"ignore@^5.2.0": "https://registry.yarnpkg.com/ignore/-/ignore-5.2.0.tgz#6d3bac8fa7fe0d45d9f9be7bac2fc279577e345a",
|
||||
"is-binary-path@~2.1.0": "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09",
|
||||
"is-core-module@^2.9.0": "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.11.0.tgz#ad4cb3e3863e814523c96f3f58d26cc570ff0144",
|
||||
"is-extglob@^2.1.1": "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2",
|
||||
"is-fullwidth-code-point@^3.0.0": "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d",
|
||||
"is-glob@^4.0.1": "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084",
|
||||
"is-glob@^4.0.3": "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084",
|
||||
"is-glob@~4.0.1": "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084",
|
||||
"is-number@^7.0.0": "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b",
|
||||
"jsonfile@^6.0.1": "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae",
|
||||
"lilconfig@^2.0.5": "https://registry.yarnpkg.com/lilconfig/-/lilconfig-2.0.6.tgz#32a384558bd58af3d4c6e077dd1ad1d397bc69d4",
|
||||
"lilconfig@^2.0.6": "https://registry.yarnpkg.com/lilconfig/-/lilconfig-2.0.6.tgz#32a384558bd58af3d4c6e077dd1ad1d397bc69d4",
|
||||
"lodash.castarray@^4.4.0": "https://registry.yarnpkg.com/lodash.castarray/-/lodash.castarray-4.4.0.tgz#c02513515e309daddd4c24c60cfddcf5976d9115",
|
||||
"lodash.isplainobject@^4.0.6": "https://registry.yarnpkg.com/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz#7c526a52d89b45c45cc690b88163be0497f550cb",
|
||||
"lodash.merge@^4.6.2": "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a",
|
||||
"lodash@^4.17.21": "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c",
|
||||
"merge2@^1.3.0": "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae",
|
||||
"merge2@^1.4.1": "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae",
|
||||
"micromatch@^4.0.4": "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6",
|
||||
"micromatch@^4.0.5": "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6",
|
||||
"minimist@^1.2.6": "https://registry.yarnpkg.com/minimist/-/minimist-1.2.7.tgz#daa1c4d91f507390437c6a8bc01078e7000c4d18",
|
||||
"nanoid@^3.3.4": "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.4.tgz#730b67e3cd09e2deacf03c027c81c9d9dbc5e8ab",
|
||||
"node-releases@^2.0.6": "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.6.tgz#8a7088c63a55e493845683ebf3c828d8c51c5503",
|
||||
"normalize-path@^3.0.0": "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65",
|
||||
"normalize-path@~3.0.0": "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65",
|
||||
"normalize-range@^0.1.2": "https://registry.yarnpkg.com/normalize-range/-/normalize-range-0.1.2.tgz#2d10c06bdfd312ea9777695a4d28439456b75942",
|
||||
"object-hash@^3.0.0": "https://registry.yarnpkg.com/object-hash/-/object-hash-3.0.0.tgz#73f97f753e7baffc0e2cc9d6e079079744ac82e9",
|
||||
"path-parse@^1.0.7": "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735",
|
||||
"path-type@^4.0.0": "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b",
|
||||
"picocolors@^1.0.0": "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c",
|
||||
"picomatch@^2.0.4": "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42",
|
||||
"picomatch@^2.2.1": "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42",
|
||||
"picomatch@^2.3.1": "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42",
|
||||
"pify@^2.3.0": "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c",
|
||||
"postcss-cli@^10.0.0": "https://registry.yarnpkg.com/postcss-cli/-/postcss-cli-10.0.0.tgz#404e468d1ff39fb5ead3f707e2021be7cd3f8c9f",
|
||||
"postcss-import@^14.1.0": "https://registry.yarnpkg.com/postcss-import/-/postcss-import-14.1.0.tgz#a7333ffe32f0b8795303ee9e40215dac922781f0",
|
||||
"postcss-js@^4.0.0": "https://registry.yarnpkg.com/postcss-js/-/postcss-js-4.0.0.tgz#31db79889531b80dc7bc9b0ad283e418dce0ac00",
|
||||
"postcss-load-config@^3.1.4": "https://registry.yarnpkg.com/postcss-load-config/-/postcss-load-config-3.1.4.tgz#1ab2571faf84bb078877e1d07905eabe9ebda855",
|
||||
"postcss-load-config@^4.0.0": "https://registry.yarnpkg.com/postcss-load-config/-/postcss-load-config-4.0.1.tgz#152383f481c2758274404e4962743191d73875bd",
|
||||
"postcss-nested@6.0.0": "https://registry.yarnpkg.com/postcss-nested/-/postcss-nested-6.0.0.tgz#1572f1984736578f360cffc7eb7dca69e30d1735",
|
||||
"postcss-reporter@^7.0.0": "https://registry.yarnpkg.com/postcss-reporter/-/postcss-reporter-7.0.5.tgz#e55bd0fdf8d17e4f25fb55e9143fcd79349a2ceb",
|
||||
"postcss-selector-parser@6.0.10": "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz#79b61e2c0d1bfc2602d549e11d0876256f8df88d",
|
||||
"postcss-selector-parser@^6.0.10": "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz#79b61e2c0d1bfc2602d549e11d0876256f8df88d",
|
||||
"postcss-value-parser@^4.0.0": "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz#723c09920836ba6d3e5af019f92bc0971c02e514",
|
||||
"postcss-value-parser@^4.2.0": "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz#723c09920836ba6d3e5af019f92bc0971c02e514",
|
||||
"postcss@^8.4.17": "https://registry.yarnpkg.com/postcss/-/postcss-8.4.18.tgz#6d50046ea7d3d66a85e0e782074e7203bc7fbca2",
|
||||
"postcss@^8.4.18": "https://registry.yarnpkg.com/postcss/-/postcss-8.4.18.tgz#6d50046ea7d3d66a85e0e782074e7203bc7fbca2",
|
||||
"pretty-hrtime@^1.0.3": "https://registry.yarnpkg.com/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz#b7e3ea42435a4c9b2759d99e0f201eb195802ee1",
|
||||
"queue-microtask@^1.2.2": "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243",
|
||||
"quick-lru@^5.1.1": "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932",
|
||||
"read-cache@^1.0.0": "https://registry.yarnpkg.com/read-cache/-/read-cache-1.0.0.tgz#e664ef31161166c9751cdbe8dbcf86b5fb58f774",
|
||||
"readdirp@~3.6.0": "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7",
|
||||
"require-directory@^2.1.1": "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42",
|
||||
"resolve@^1.1.7": "https://registry.yarnpkg.com/resolve/-/resolve-1.22.1.tgz#27cb2ebb53f91abb49470a928bba7558066ac177",
|
||||
"resolve@^1.22.1": "https://registry.yarnpkg.com/resolve/-/resolve-1.22.1.tgz#27cb2ebb53f91abb49470a928bba7558066ac177",
|
||||
"reusify@^1.0.4": "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76",
|
||||
"run-parallel@^1.1.9": "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee",
|
||||
"rxjs@^7.0.0": "https://registry.yarnpkg.com/rxjs/-/rxjs-7.5.7.tgz#2ec0d57fdc89ece220d2e702730ae8f1e49def39",
|
||||
"shell-quote@^1.7.3": "https://registry.yarnpkg.com/shell-quote/-/shell-quote-1.7.4.tgz#33fe15dee71ab2a81fcbd3a52106c5cfb9fb75d8",
|
||||
"slash@^4.0.0": "https://registry.yarnpkg.com/slash/-/slash-4.0.0.tgz#2422372176c4c6c5addb5e2ada885af984b396a7",
|
||||
"source-map-js@^1.0.2": "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.0.2.tgz#adbc361d9c62df380125e7f161f71c826f1e490c",
|
||||
"spawn-command@^0.0.2-1": "https://registry.yarnpkg.com/spawn-command/-/spawn-command-0.0.2-1.tgz#62f5e9466981c1b796dc5929937e11c9c6921bd0",
|
||||
"string-width@^4.1.0": "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010",
|
||||
"string-width@^4.2.0": "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010",
|
||||
"string-width@^4.2.3": "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010",
|
||||
"strip-ansi@^6.0.0": "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9",
|
||||
"strip-ansi@^6.0.1": "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9",
|
||||
"supports-color@^7.1.0": "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da",
|
||||
"supports-color@^8.1.0": "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c",
|
||||
"supports-preserve-symlinks-flag@^1.0.0": "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09",
|
||||
"tailwindcss@^3.2.1": "https://registry.yarnpkg.com/tailwindcss/-/tailwindcss-3.2.1.tgz#1bd828fff3172489962357f8d531c184080a6786",
|
||||
"thenby@^1.3.4": "https://registry.yarnpkg.com/thenby/-/thenby-1.3.4.tgz#81581f6e1bb324c6dedeae9bfc28e59b1a2201cc",
|
||||
"to-regex-range@^5.0.1": "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4",
|
||||
"tree-kill@^1.2.2": "https://registry.yarnpkg.com/tree-kill/-/tree-kill-1.2.2.tgz#4ca09a9092c88b73a7cdc5e8a01b507b0790a0cc",
|
||||
"tslib@^2.1.0": "https://registry.yarnpkg.com/tslib/-/tslib-2.4.0.tgz#7cecaa7f073ce680a05847aa77be941098f36dc3",
|
||||
"universalify@^2.0.0": "https://registry.yarnpkg.com/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717",
|
||||
"update-browserslist-db@^1.0.9": "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz#0f54b876545726f17d00cd9a2561e6dade943ff3",
|
||||
"util-deprecate@^1.0.2": "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf",
|
||||
"wrap-ansi@^7.0.0": "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43",
|
||||
"xtend@^4.0.2": "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54",
|
||||
"y18n@^5.0.5": "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55",
|
||||
"yaml@^1.10.2": "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b",
|
||||
"yaml@^2.1.1": "https://registry.yarnpkg.com/yaml/-/yaml-2.1.3.tgz#9b3a4c8aff9821b696275c79a8bee8399d945207",
|
||||
"yargs-parser@^21.0.0": "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35",
|
||||
"yargs@^17.0.0": "https://registry.yarnpkg.com/yargs/-/yargs-17.6.0.tgz#e134900fc1f218bc230192bdec06a0a5f973e46c",
|
||||
"yargs@^17.3.1": "https://registry.yarnpkg.com/yargs/-/yargs-17.6.0.tgz#e134900fc1f218bc230192bdec06a0a5f973e46c"
|
||||
},
|
||||
"files": [],
|
||||
"artifacts": {}
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) Denis Malinochkin
|
||||
|
||||
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.
|
||||
|
|
@ -1,171 +0,0 @@
|
|||
# @nodelib/fs.scandir
|
||||
|
||||
> List files and directories inside the specified directory.
|
||||
|
||||
## :bulb: Highlights
|
||||
|
||||
The package is aimed at obtaining information about entries in the directory.
|
||||
|
||||
* :moneybag: Returns useful information: `name`, `path`, `dirent` and `stats` (optional).
|
||||
* :gear: On Node.js 10.10+ uses the mechanism without additional calls to determine the entry type. See [`old` and `modern` mode](#old-and-modern-mode).
|
||||
* :link: Can safely work with broken symbolic links.
|
||||
|
||||
## Install
|
||||
|
||||
```console
|
||||
npm install @nodelib/fs.scandir
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```ts
|
||||
import * as fsScandir from '@nodelib/fs.scandir';
|
||||
|
||||
fsScandir.scandir('path', (error, stats) => { /* … */ });
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
### .scandir(path, [optionsOrSettings], callback)
|
||||
|
||||
Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path with standard callback-style.
|
||||
|
||||
```ts
|
||||
fsScandir.scandir('path', (error, entries) => { /* … */ });
|
||||
fsScandir.scandir('path', {}, (error, entries) => { /* … */ });
|
||||
fsScandir.scandir('path', new fsScandir.Settings(), (error, entries) => { /* … */ });
|
||||
```
|
||||
|
||||
### .scandirSync(path, [optionsOrSettings])
|
||||
|
||||
Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path.
|
||||
|
||||
```ts
|
||||
const entries = fsScandir.scandirSync('path');
|
||||
const entries = fsScandir.scandirSync('path', {});
|
||||
const entries = fsScandir.scandirSync(('path', new fsScandir.Settings());
|
||||
```
|
||||
|
||||
#### path
|
||||
|
||||
* Required: `true`
|
||||
* Type: `string | Buffer | URL`
|
||||
|
||||
A path to a file. If a URL is provided, it must use the `file:` protocol.
|
||||
|
||||
#### optionsOrSettings
|
||||
|
||||
* Required: `false`
|
||||
* Type: `Options | Settings`
|
||||
* Default: An instance of `Settings` class
|
||||
|
||||
An [`Options`](#options) object or an instance of [`Settings`](#settingsoptions) class.
|
||||
|
||||
> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
|
||||
|
||||
### Settings([options])
|
||||
|
||||
A class of full settings of the package.
|
||||
|
||||
```ts
|
||||
const settings = new fsScandir.Settings({ followSymbolicLinks: false });
|
||||
|
||||
const entries = fsScandir.scandirSync('path', settings);
|
||||
```
|
||||
|
||||
## Entry
|
||||
|
||||
* `name` — The name of the entry (`unknown.txt`).
|
||||
* `path` — The path of the entry relative to call directory (`root/unknown.txt`).
|
||||
* `dirent` — An instance of [`fs.Dirent`](./src/types/index.ts) class. On Node.js below 10.10 will be emulated by [`DirentFromStats`](./src/utils/fs.ts) class.
|
||||
* `stats` (optional) — An instance of `fs.Stats` class.
|
||||
|
||||
For example, the `scandir` call for `tools` directory with one directory inside:
|
||||
|
||||
```ts
|
||||
{
|
||||
dirent: Dirent { name: 'typedoc', /* … */ },
|
||||
name: 'typedoc',
|
||||
path: 'tools/typedoc'
|
||||
}
|
||||
```
|
||||
|
||||
## Options
|
||||
|
||||
### stats
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Adds an instance of `fs.Stats` class to the [`Entry`](#entry).
|
||||
|
||||
> :book: Always use `fs.readdir` without the `withFileTypes` option. ??TODO??
|
||||
|
||||
### followSymbolicLinks
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Follow symbolic links or not. Call `fs.stat` on symbolic link if `true`.
|
||||
|
||||
### `throwErrorOnBrokenSymbolicLink`
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Throw an error when symbolic link is broken if `true` or safely use `lstat` call if `false`.
|
||||
|
||||
### `pathSegmentSeparator`
|
||||
|
||||
* Type: `string`
|
||||
* Default: `path.sep`
|
||||
|
||||
By default, this package uses the correct path separator for your OS (`\` on Windows, `/` on Unix-like systems). But you can set this option to any separator character(s) that you want to use instead.
|
||||
|
||||
### `fs`
|
||||
|
||||
* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
|
||||
* Default: A default FS methods
|
||||
|
||||
By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
|
||||
|
||||
```ts
|
||||
interface FileSystemAdapter {
|
||||
lstat?: typeof fs.lstat;
|
||||
stat?: typeof fs.stat;
|
||||
lstatSync?: typeof fs.lstatSync;
|
||||
statSync?: typeof fs.statSync;
|
||||
readdir?: typeof fs.readdir;
|
||||
readdirSync?: typeof fs.readdirSync;
|
||||
}
|
||||
|
||||
const settings = new fsScandir.Settings({
|
||||
fs: { lstat: fakeLstat }
|
||||
});
|
||||
```
|
||||
|
||||
## `old` and `modern` mode
|
||||
|
||||
This package has two modes that are used depending on the environment and parameters of use.
|
||||
|
||||
### old
|
||||
|
||||
* Node.js below `10.10` or when the `stats` option is enabled
|
||||
|
||||
When working in the old mode, the directory is read first (`fs.readdir`), then the type of entries is determined (`fs.lstat` and/or `fs.stat` for symbolic links).
|
||||
|
||||
### modern
|
||||
|
||||
* Node.js 10.10+ and the `stats` option is disabled
|
||||
|
||||
In the modern mode, reading the directory (`fs.readdir` with the `withFileTypes` option) is combined with obtaining information about its entries. An additional call for symbolic links (`fs.stat`) is still present.
|
||||
|
||||
This mode makes fewer calls to the file system. It's faster.
|
||||
|
||||
## Changelog
|
||||
|
||||
See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
|
||||
|
||||
## License
|
||||
|
||||
This software is released under the terms of the MIT license.
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
import type * as fsStat from '@nodelib/fs.stat';
|
||||
import type { Dirent, ErrnoException } from '../types';
|
||||
export interface ReaddirAsynchronousMethod {
|
||||
(filepath: string, options: {
|
||||
withFileTypes: true;
|
||||
}, callback: (error: ErrnoException | null, files: Dirent[]) => void): void;
|
||||
(filepath: string, callback: (error: ErrnoException | null, files: string[]) => void): void;
|
||||
}
|
||||
export interface ReaddirSynchronousMethod {
|
||||
(filepath: string, options: {
|
||||
withFileTypes: true;
|
||||
}): Dirent[];
|
||||
(filepath: string): string[];
|
||||
}
|
||||
export declare type FileSystemAdapter = fsStat.FileSystemAdapter & {
|
||||
readdir: ReaddirAsynchronousMethod;
|
||||
readdirSync: ReaddirSynchronousMethod;
|
||||
};
|
||||
export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
|
||||
export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
|
||||
const fs = require("fs");
|
||||
exports.FILE_SYSTEM_ADAPTER = {
|
||||
lstat: fs.lstat,
|
||||
stat: fs.stat,
|
||||
lstatSync: fs.lstatSync,
|
||||
statSync: fs.statSync,
|
||||
readdir: fs.readdir,
|
||||
readdirSync: fs.readdirSync
|
||||
};
|
||||
function createFileSystemAdapter(fsMethods) {
|
||||
if (fsMethods === undefined) {
|
||||
return exports.FILE_SYSTEM_ADAPTER;
|
||||
}
|
||||
return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
|
||||
}
|
||||
exports.createFileSystemAdapter = createFileSystemAdapter;
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
/**
|
||||
* IS `true` for Node.js 10.10 and greater.
|
||||
*/
|
||||
export declare const IS_SUPPORT_READDIR_WITH_FILE_TYPES: boolean;
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
|
||||
const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
|
||||
if (NODE_PROCESS_VERSION_PARTS[0] === undefined || NODE_PROCESS_VERSION_PARTS[1] === undefined) {
|
||||
throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
|
||||
}
|
||||
const MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
|
||||
const MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
|
||||
const SUPPORTED_MAJOR_VERSION = 10;
|
||||
const SUPPORTED_MINOR_VERSION = 10;
|
||||
const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
|
||||
const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
|
||||
/**
|
||||
* IS `true` for Node.js 10.10 and greater.
|
||||
*/
|
||||
exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
import type { FileSystemAdapter, ReaddirAsynchronousMethod, ReaddirSynchronousMethod } from './adapters/fs';
|
||||
import * as async from './providers/async';
|
||||
import Settings, { Options } from './settings';
|
||||
import type { Dirent, Entry } from './types';
|
||||
declare type AsyncCallback = async.AsyncCallback;
|
||||
declare function scandir(path: string, callback: AsyncCallback): void;
|
||||
declare function scandir(path: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
|
||||
declare namespace scandir {
|
||||
function __promisify__(path: string, optionsOrSettings?: Options | Settings): Promise<Entry[]>;
|
||||
}
|
||||
declare function scandirSync(path: string, optionsOrSettings?: Options | Settings): Entry[];
|
||||
export { scandir, scandirSync, Settings, AsyncCallback, Dirent, Entry, FileSystemAdapter, ReaddirAsynchronousMethod, ReaddirSynchronousMethod, Options };
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Settings = exports.scandirSync = exports.scandir = void 0;
|
||||
const async = require("./providers/async");
|
||||
const sync = require("./providers/sync");
|
||||
const settings_1 = require("./settings");
|
||||
exports.Settings = settings_1.default;
|
||||
function scandir(path, optionsOrSettingsOrCallback, callback) {
|
||||
if (typeof optionsOrSettingsOrCallback === 'function') {
|
||||
async.read(path, getSettings(), optionsOrSettingsOrCallback);
|
||||
return;
|
||||
}
|
||||
async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
|
||||
}
|
||||
exports.scandir = scandir;
|
||||
function scandirSync(path, optionsOrSettings) {
|
||||
const settings = getSettings(optionsOrSettings);
|
||||
return sync.read(path, settings);
|
||||
}
|
||||
exports.scandirSync = scandirSync;
|
||||
function getSettings(settingsOrOptions = {}) {
|
||||
if (settingsOrOptions instanceof settings_1.default) {
|
||||
return settingsOrOptions;
|
||||
}
|
||||
return new settings_1.default(settingsOrOptions);
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
/// <reference types="node" />
|
||||
import type Settings from '../settings';
|
||||
import type { Entry } from '../types';
|
||||
export declare type AsyncCallback = (error: NodeJS.ErrnoException, entries: Entry[]) => void;
|
||||
export declare function read(directory: string, settings: Settings, callback: AsyncCallback): void;
|
||||
export declare function readdirWithFileTypes(directory: string, settings: Settings, callback: AsyncCallback): void;
|
||||
export declare function readdir(directory: string, settings: Settings, callback: AsyncCallback): void;
|
||||
|
|
@ -1,104 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.readdir = exports.readdirWithFileTypes = exports.read = void 0;
|
||||
const fsStat = require("@nodelib/fs.stat");
|
||||
const rpl = require("run-parallel");
|
||||
const constants_1 = require("../constants");
|
||||
const utils = require("../utils");
|
||||
const common = require("./common");
|
||||
function read(directory, settings, callback) {
|
||||
if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
|
||||
readdirWithFileTypes(directory, settings, callback);
|
||||
return;
|
||||
}
|
||||
readdir(directory, settings, callback);
|
||||
}
|
||||
exports.read = read;
|
||||
function readdirWithFileTypes(directory, settings, callback) {
|
||||
settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
|
||||
if (readdirError !== null) {
|
||||
callFailureCallback(callback, readdirError);
|
||||
return;
|
||||
}
|
||||
const entries = dirents.map((dirent) => ({
|
||||
dirent,
|
||||
name: dirent.name,
|
||||
path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
|
||||
}));
|
||||
if (!settings.followSymbolicLinks) {
|
||||
callSuccessCallback(callback, entries);
|
||||
return;
|
||||
}
|
||||
const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
|
||||
rpl(tasks, (rplError, rplEntries) => {
|
||||
if (rplError !== null) {
|
||||
callFailureCallback(callback, rplError);
|
||||
return;
|
||||
}
|
||||
callSuccessCallback(callback, rplEntries);
|
||||
});
|
||||
});
|
||||
}
|
||||
exports.readdirWithFileTypes = readdirWithFileTypes;
|
||||
function makeRplTaskEntry(entry, settings) {
|
||||
return (done) => {
|
||||
if (!entry.dirent.isSymbolicLink()) {
|
||||
done(null, entry);
|
||||
return;
|
||||
}
|
||||
settings.fs.stat(entry.path, (statError, stats) => {
|
||||
if (statError !== null) {
|
||||
if (settings.throwErrorOnBrokenSymbolicLink) {
|
||||
done(statError);
|
||||
return;
|
||||
}
|
||||
done(null, entry);
|
||||
return;
|
||||
}
|
||||
entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
|
||||
done(null, entry);
|
||||
});
|
||||
};
|
||||
}
|
||||
function readdir(directory, settings, callback) {
|
||||
settings.fs.readdir(directory, (readdirError, names) => {
|
||||
if (readdirError !== null) {
|
||||
callFailureCallback(callback, readdirError);
|
||||
return;
|
||||
}
|
||||
const tasks = names.map((name) => {
|
||||
const path = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
|
||||
return (done) => {
|
||||
fsStat.stat(path, settings.fsStatSettings, (error, stats) => {
|
||||
if (error !== null) {
|
||||
done(error);
|
||||
return;
|
||||
}
|
||||
const entry = {
|
||||
name,
|
||||
path,
|
||||
dirent: utils.fs.createDirentFromStats(name, stats)
|
||||
};
|
||||
if (settings.stats) {
|
||||
entry.stats = stats;
|
||||
}
|
||||
done(null, entry);
|
||||
});
|
||||
};
|
||||
});
|
||||
rpl(tasks, (rplError, entries) => {
|
||||
if (rplError !== null) {
|
||||
callFailureCallback(callback, rplError);
|
||||
return;
|
||||
}
|
||||
callSuccessCallback(callback, entries);
|
||||
});
|
||||
});
|
||||
}
|
||||
exports.readdir = readdir;
|
||||
function callFailureCallback(callback, error) {
|
||||
callback(error);
|
||||
}
|
||||
function callSuccessCallback(callback, result) {
|
||||
callback(null, result);
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
export declare function joinPathSegments(a: string, b: string, separator: string): string;
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.joinPathSegments = void 0;
|
||||
function joinPathSegments(a, b, separator) {
|
||||
/**
|
||||
* The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
|
||||
*/
|
||||
if (a.endsWith(separator)) {
|
||||
return a + b;
|
||||
}
|
||||
return a + separator + b;
|
||||
}
|
||||
exports.joinPathSegments = joinPathSegments;
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
import type Settings from '../settings';
|
||||
import type { Entry } from '../types';
|
||||
export declare function read(directory: string, settings: Settings): Entry[];
|
||||
export declare function readdirWithFileTypes(directory: string, settings: Settings): Entry[];
|
||||
export declare function readdir(directory: string, settings: Settings): Entry[];
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.readdir = exports.readdirWithFileTypes = exports.read = void 0;
|
||||
const fsStat = require("@nodelib/fs.stat");
|
||||
const constants_1 = require("../constants");
|
||||
const utils = require("../utils");
|
||||
const common = require("./common");
|
||||
function read(directory, settings) {
|
||||
if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
|
||||
return readdirWithFileTypes(directory, settings);
|
||||
}
|
||||
return readdir(directory, settings);
|
||||
}
|
||||
exports.read = read;
|
||||
function readdirWithFileTypes(directory, settings) {
|
||||
const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
|
||||
return dirents.map((dirent) => {
|
||||
const entry = {
|
||||
dirent,
|
||||
name: dirent.name,
|
||||
path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
|
||||
};
|
||||
if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
|
||||
try {
|
||||
const stats = settings.fs.statSync(entry.path);
|
||||
entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
|
||||
}
|
||||
catch (error) {
|
||||
if (settings.throwErrorOnBrokenSymbolicLink) {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
return entry;
|
||||
});
|
||||
}
|
||||
exports.readdirWithFileTypes = readdirWithFileTypes;
|
||||
function readdir(directory, settings) {
|
||||
const names = settings.fs.readdirSync(directory);
|
||||
return names.map((name) => {
|
||||
const entryPath = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
|
||||
const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
|
||||
const entry = {
|
||||
name,
|
||||
path: entryPath,
|
||||
dirent: utils.fs.createDirentFromStats(name, stats)
|
||||
};
|
||||
if (settings.stats) {
|
||||
entry.stats = stats;
|
||||
}
|
||||
return entry;
|
||||
});
|
||||
}
|
||||
exports.readdir = readdir;
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
import * as fsStat from '@nodelib/fs.stat';
|
||||
import * as fs from './adapters/fs';
|
||||
export interface Options {
|
||||
followSymbolicLinks?: boolean;
|
||||
fs?: Partial<fs.FileSystemAdapter>;
|
||||
pathSegmentSeparator?: string;
|
||||
stats?: boolean;
|
||||
throwErrorOnBrokenSymbolicLink?: boolean;
|
||||
}
|
||||
export default class Settings {
|
||||
private readonly _options;
|
||||
readonly followSymbolicLinks: boolean;
|
||||
readonly fs: fs.FileSystemAdapter;
|
||||
readonly pathSegmentSeparator: string;
|
||||
readonly stats: boolean;
|
||||
readonly throwErrorOnBrokenSymbolicLink: boolean;
|
||||
readonly fsStatSettings: fsStat.Settings;
|
||||
constructor(_options?: Options);
|
||||
private _getValue;
|
||||
}
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const path = require("path");
|
||||
const fsStat = require("@nodelib/fs.stat");
|
||||
const fs = require("./adapters/fs");
|
||||
class Settings {
|
||||
constructor(_options = {}) {
|
||||
this._options = _options;
|
||||
this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
|
||||
this.fs = fs.createFileSystemAdapter(this._options.fs);
|
||||
this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
|
||||
this.stats = this._getValue(this._options.stats, false);
|
||||
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
|
||||
this.fsStatSettings = new fsStat.Settings({
|
||||
followSymbolicLink: this.followSymbolicLinks,
|
||||
fs: this.fs,
|
||||
throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
|
||||
});
|
||||
}
|
||||
_getValue(option, value) {
|
||||
return option !== null && option !== void 0 ? option : value;
|
||||
}
|
||||
}
|
||||
exports.default = Settings;
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
/// <reference types="node" />
|
||||
import type * as fs from 'fs';
|
||||
export interface Entry {
|
||||
dirent: Dirent;
|
||||
name: string;
|
||||
path: string;
|
||||
stats?: Stats;
|
||||
}
|
||||
export declare type Stats = fs.Stats;
|
||||
export declare type ErrnoException = NodeJS.ErrnoException;
|
||||
export interface Dirent {
|
||||
isBlockDevice: () => boolean;
|
||||
isCharacterDevice: () => boolean;
|
||||
isDirectory: () => boolean;
|
||||
isFIFO: () => boolean;
|
||||
isFile: () => boolean;
|
||||
isSocket: () => boolean;
|
||||
isSymbolicLink: () => boolean;
|
||||
name: string;
|
||||
}
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
import type { Dirent, Stats } from '../types';
|
||||
export declare function createDirentFromStats(name: string, stats: Stats): Dirent;
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createDirentFromStats = void 0;
|
||||
class DirentFromStats {
|
||||
constructor(name, stats) {
|
||||
this.name = name;
|
||||
this.isBlockDevice = stats.isBlockDevice.bind(stats);
|
||||
this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
|
||||
this.isDirectory = stats.isDirectory.bind(stats);
|
||||
this.isFIFO = stats.isFIFO.bind(stats);
|
||||
this.isFile = stats.isFile.bind(stats);
|
||||
this.isSocket = stats.isSocket.bind(stats);
|
||||
this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
|
||||
}
|
||||
}
|
||||
function createDirentFromStats(name, stats) {
|
||||
return new DirentFromStats(name, stats);
|
||||
}
|
||||
exports.createDirentFromStats = createDirentFromStats;
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
import * as fs from './fs';
|
||||
export { fs };
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.fs = void 0;
|
||||
const fs = require("./fs");
|
||||
exports.fs = fs;
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
{
|
||||
"name": "@nodelib/fs.scandir",
|
||||
"version": "2.1.5",
|
||||
"description": "List files and directories inside the specified directory",
|
||||
"license": "MIT",
|
||||
"repository": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.scandir",
|
||||
"keywords": [
|
||||
"NodeLib",
|
||||
"fs",
|
||||
"FileSystem",
|
||||
"file system",
|
||||
"scandir",
|
||||
"readdir",
|
||||
"dirent"
|
||||
],
|
||||
"engines": {
|
||||
"node": ">= 8"
|
||||
},
|
||||
"files": [
|
||||
"out/**",
|
||||
"!out/**/*.map",
|
||||
"!out/**/*.spec.*"
|
||||
],
|
||||
"main": "out/index.js",
|
||||
"typings": "out/index.d.ts",
|
||||
"scripts": {
|
||||
"clean": "rimraf {tsconfig.tsbuildinfo,out}",
|
||||
"lint": "eslint \"src/**/*.ts\" --cache",
|
||||
"compile": "tsc -b .",
|
||||
"compile:watch": "tsc -p . --watch --sourceMap",
|
||||
"test": "mocha \"out/**/*.spec.js\" -s 0",
|
||||
"build": "npm run clean && npm run compile && npm run lint && npm test",
|
||||
"watch": "npm run clean && npm run compile:watch"
|
||||
},
|
||||
"dependencies": {
|
||||
"@nodelib/fs.stat": "2.0.5",
|
||||
"run-parallel": "^1.1.9"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@nodelib/fs.macchiato": "1.0.4",
|
||||
"@types/run-parallel": "^1.1.0"
|
||||
},
|
||||
"gitHead": "d6a7960d5281d3dd5f8e2efba49bb552d090f562"
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) Denis Malinochkin
|
||||
|
||||
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.
|
||||
|
|
@ -1,126 +0,0 @@
|
|||
# @nodelib/fs.stat
|
||||
|
||||
> Get the status of a file with some features.
|
||||
|
||||
## :bulb: Highlights
|
||||
|
||||
Wrapper around standard method `fs.lstat` and `fs.stat` with some features.
|
||||
|
||||
* :beginner: Normally follows symbolic link.
|
||||
* :gear: Can safely work with broken symbolic link.
|
||||
|
||||
## Install
|
||||
|
||||
```console
|
||||
npm install @nodelib/fs.stat
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```ts
|
||||
import * as fsStat from '@nodelib/fs.stat';
|
||||
|
||||
fsStat.stat('path', (error, stats) => { /* … */ });
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
### .stat(path, [optionsOrSettings], callback)
|
||||
|
||||
Returns an instance of `fs.Stats` class for provided path with standard callback-style.
|
||||
|
||||
```ts
|
||||
fsStat.stat('path', (error, stats) => { /* … */ });
|
||||
fsStat.stat('path', {}, (error, stats) => { /* … */ });
|
||||
fsStat.stat('path', new fsStat.Settings(), (error, stats) => { /* … */ });
|
||||
```
|
||||
|
||||
### .statSync(path, [optionsOrSettings])
|
||||
|
||||
Returns an instance of `fs.Stats` class for provided path.
|
||||
|
||||
```ts
|
||||
const stats = fsStat.stat('path');
|
||||
const stats = fsStat.stat('path', {});
|
||||
const stats = fsStat.stat('path', new fsStat.Settings());
|
||||
```
|
||||
|
||||
#### path
|
||||
|
||||
* Required: `true`
|
||||
* Type: `string | Buffer | URL`
|
||||
|
||||
A path to a file. If a URL is provided, it must use the `file:` protocol.
|
||||
|
||||
#### optionsOrSettings
|
||||
|
||||
* Required: `false`
|
||||
* Type: `Options | Settings`
|
||||
* Default: An instance of `Settings` class
|
||||
|
||||
An [`Options`](#options) object or an instance of [`Settings`](#settings) class.
|
||||
|
||||
> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
|
||||
|
||||
### Settings([options])
|
||||
|
||||
A class of full settings of the package.
|
||||
|
||||
```ts
|
||||
const settings = new fsStat.Settings({ followSymbolicLink: false });
|
||||
|
||||
const stats = fsStat.stat('path', settings);
|
||||
```
|
||||
|
||||
## Options
|
||||
|
||||
### `followSymbolicLink`
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Follow symbolic link or not. Call `fs.stat` on symbolic link if `true`.
|
||||
|
||||
### `markSymbolicLink`
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Mark symbolic link by setting the return value of `isSymbolicLink` function to always `true` (even after `fs.stat`).
|
||||
|
||||
> :book: Can be used if you want to know what is hidden behind a symbolic link, but still continue to know that it is a symbolic link.
|
||||
|
||||
### `throwErrorOnBrokenSymbolicLink`
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
|
||||
|
||||
### `fs`
|
||||
|
||||
* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
|
||||
* Default: A default FS methods
|
||||
|
||||
By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
|
||||
|
||||
```ts
|
||||
interface FileSystemAdapter {
|
||||
lstat?: typeof fs.lstat;
|
||||
stat?: typeof fs.stat;
|
||||
lstatSync?: typeof fs.lstatSync;
|
||||
statSync?: typeof fs.statSync;
|
||||
}
|
||||
|
||||
const settings = new fsStat.Settings({
|
||||
fs: { lstat: fakeLstat }
|
||||
});
|
||||
```
|
||||
|
||||
## Changelog
|
||||
|
||||
See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
|
||||
|
||||
## License
|
||||
|
||||
This software is released under the terms of the MIT license.
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
/// <reference types="node" />
|
||||
import * as fs from 'fs';
|
||||
import type { ErrnoException } from '../types';
|
||||
export declare type StatAsynchronousMethod = (path: string, callback: (error: ErrnoException | null, stats: fs.Stats) => void) => void;
|
||||
export declare type StatSynchronousMethod = (path: string) => fs.Stats;
|
||||
export interface FileSystemAdapter {
|
||||
lstat: StatAsynchronousMethod;
|
||||
stat: StatAsynchronousMethod;
|
||||
lstatSync: StatSynchronousMethod;
|
||||
statSync: StatSynchronousMethod;
|
||||
}
|
||||
export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
|
||||
export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
|
||||
const fs = require("fs");
|
||||
exports.FILE_SYSTEM_ADAPTER = {
|
||||
lstat: fs.lstat,
|
||||
stat: fs.stat,
|
||||
lstatSync: fs.lstatSync,
|
||||
statSync: fs.statSync
|
||||
};
|
||||
function createFileSystemAdapter(fsMethods) {
|
||||
if (fsMethods === undefined) {
|
||||
return exports.FILE_SYSTEM_ADAPTER;
|
||||
}
|
||||
return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
|
||||
}
|
||||
exports.createFileSystemAdapter = createFileSystemAdapter;
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
import type { FileSystemAdapter, StatAsynchronousMethod, StatSynchronousMethod } from './adapters/fs';
|
||||
import * as async from './providers/async';
|
||||
import Settings, { Options } from './settings';
|
||||
import type { Stats } from './types';
|
||||
declare type AsyncCallback = async.AsyncCallback;
|
||||
declare function stat(path: string, callback: AsyncCallback): void;
|
||||
declare function stat(path: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
|
||||
declare namespace stat {
|
||||
function __promisify__(path: string, optionsOrSettings?: Options | Settings): Promise<Stats>;
|
||||
}
|
||||
declare function statSync(path: string, optionsOrSettings?: Options | Settings): Stats;
|
||||
export { Settings, stat, statSync, AsyncCallback, FileSystemAdapter, StatAsynchronousMethod, StatSynchronousMethod, Options, Stats };
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.statSync = exports.stat = exports.Settings = void 0;
|
||||
const async = require("./providers/async");
|
||||
const sync = require("./providers/sync");
|
||||
const settings_1 = require("./settings");
|
||||
exports.Settings = settings_1.default;
|
||||
function stat(path, optionsOrSettingsOrCallback, callback) {
|
||||
if (typeof optionsOrSettingsOrCallback === 'function') {
|
||||
async.read(path, getSettings(), optionsOrSettingsOrCallback);
|
||||
return;
|
||||
}
|
||||
async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
|
||||
}
|
||||
exports.stat = stat;
|
||||
function statSync(path, optionsOrSettings) {
|
||||
const settings = getSettings(optionsOrSettings);
|
||||
return sync.read(path, settings);
|
||||
}
|
||||
exports.statSync = statSync;
|
||||
function getSettings(settingsOrOptions = {}) {
|
||||
if (settingsOrOptions instanceof settings_1.default) {
|
||||
return settingsOrOptions;
|
||||
}
|
||||
return new settings_1.default(settingsOrOptions);
|
||||
}
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
import type Settings from '../settings';
|
||||
import type { ErrnoException, Stats } from '../types';
|
||||
export declare type AsyncCallback = (error: ErrnoException, stats: Stats) => void;
|
||||
export declare function read(path: string, settings: Settings, callback: AsyncCallback): void;
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.read = void 0;
|
||||
function read(path, settings, callback) {
|
||||
settings.fs.lstat(path, (lstatError, lstat) => {
|
||||
if (lstatError !== null) {
|
||||
callFailureCallback(callback, lstatError);
|
||||
return;
|
||||
}
|
||||
if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
|
||||
callSuccessCallback(callback, lstat);
|
||||
return;
|
||||
}
|
||||
settings.fs.stat(path, (statError, stat) => {
|
||||
if (statError !== null) {
|
||||
if (settings.throwErrorOnBrokenSymbolicLink) {
|
||||
callFailureCallback(callback, statError);
|
||||
return;
|
||||
}
|
||||
callSuccessCallback(callback, lstat);
|
||||
return;
|
||||
}
|
||||
if (settings.markSymbolicLink) {
|
||||
stat.isSymbolicLink = () => true;
|
||||
}
|
||||
callSuccessCallback(callback, stat);
|
||||
});
|
||||
});
|
||||
}
|
||||
exports.read = read;
|
||||
function callFailureCallback(callback, error) {
|
||||
callback(error);
|
||||
}
|
||||
function callSuccessCallback(callback, result) {
|
||||
callback(null, result);
|
||||
}
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
import type Settings from '../settings';
|
||||
import type { Stats } from '../types';
|
||||
export declare function read(path: string, settings: Settings): Stats;
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.read = void 0;
|
||||
function read(path, settings) {
|
||||
const lstat = settings.fs.lstatSync(path);
|
||||
if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
|
||||
return lstat;
|
||||
}
|
||||
try {
|
||||
const stat = settings.fs.statSync(path);
|
||||
if (settings.markSymbolicLink) {
|
||||
stat.isSymbolicLink = () => true;
|
||||
}
|
||||
return stat;
|
||||
}
|
||||
catch (error) {
|
||||
if (!settings.throwErrorOnBrokenSymbolicLink) {
|
||||
return lstat;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
exports.read = read;
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
import * as fs from './adapters/fs';
|
||||
export interface Options {
|
||||
followSymbolicLink?: boolean;
|
||||
fs?: Partial<fs.FileSystemAdapter>;
|
||||
markSymbolicLink?: boolean;
|
||||
throwErrorOnBrokenSymbolicLink?: boolean;
|
||||
}
|
||||
export default class Settings {
|
||||
private readonly _options;
|
||||
readonly followSymbolicLink: boolean;
|
||||
readonly fs: fs.FileSystemAdapter;
|
||||
readonly markSymbolicLink: boolean;
|
||||
readonly throwErrorOnBrokenSymbolicLink: boolean;
|
||||
constructor(_options?: Options);
|
||||
private _getValue;
|
||||
}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const fs = require("./adapters/fs");
|
||||
class Settings {
|
||||
constructor(_options = {}) {
|
||||
this._options = _options;
|
||||
this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
|
||||
this.fs = fs.createFileSystemAdapter(this._options.fs);
|
||||
this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
|
||||
this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
|
||||
}
|
||||
_getValue(option, value) {
|
||||
return option !== null && option !== void 0 ? option : value;
|
||||
}
|
||||
}
|
||||
exports.default = Settings;
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
/// <reference types="node" />
|
||||
import type * as fs from 'fs';
|
||||
export declare type Stats = fs.Stats;
|
||||
export declare type ErrnoException = NodeJS.ErrnoException;
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
{
|
||||
"name": "@nodelib/fs.stat",
|
||||
"version": "2.0.5",
|
||||
"description": "Get the status of a file with some features",
|
||||
"license": "MIT",
|
||||
"repository": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.stat",
|
||||
"keywords": [
|
||||
"NodeLib",
|
||||
"fs",
|
||||
"FileSystem",
|
||||
"file system",
|
||||
"stat"
|
||||
],
|
||||
"engines": {
|
||||
"node": ">= 8"
|
||||
},
|
||||
"files": [
|
||||
"out/**",
|
||||
"!out/**/*.map",
|
||||
"!out/**/*.spec.*"
|
||||
],
|
||||
"main": "out/index.js",
|
||||
"typings": "out/index.d.ts",
|
||||
"scripts": {
|
||||
"clean": "rimraf {tsconfig.tsbuildinfo,out}",
|
||||
"lint": "eslint \"src/**/*.ts\" --cache",
|
||||
"compile": "tsc -b .",
|
||||
"compile:watch": "tsc -p . --watch --sourceMap",
|
||||
"test": "mocha \"out/**/*.spec.js\" -s 0",
|
||||
"build": "npm run clean && npm run compile && npm run lint && npm test",
|
||||
"watch": "npm run clean && npm run compile:watch"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@nodelib/fs.macchiato": "1.0.4"
|
||||
},
|
||||
"gitHead": "d6a7960d5281d3dd5f8e2efba49bb552d090f562"
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) Denis Malinochkin
|
||||
|
||||
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.
|
||||
|
|
@ -1,215 +0,0 @@
|
|||
# @nodelib/fs.walk
|
||||
|
||||
> A library for efficiently walking a directory recursively.
|
||||
|
||||
## :bulb: Highlights
|
||||
|
||||
* :moneybag: Returns useful information: `name`, `path`, `dirent` and `stats` (optional).
|
||||
* :rocket: On Node.js 10.10+ uses the mechanism without additional calls to determine the entry type for performance reasons. See [`old` and `modern` mode](https://github.com/nodelib/nodelib/blob/master/packages/fs/fs.scandir/README.md#old-and-modern-mode).
|
||||
* :gear: Built-in directories/files and error filtering system.
|
||||
* :link: Can safely work with broken symbolic links.
|
||||
|
||||
## Install
|
||||
|
||||
```console
|
||||
npm install @nodelib/fs.walk
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```ts
|
||||
import * as fsWalk from '@nodelib/fs.walk';
|
||||
|
||||
fsWalk.walk('path', (error, entries) => { /* … */ });
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
### .walk(path, [optionsOrSettings], callback)
|
||||
|
||||
Reads the directory recursively and asynchronously. Requires a callback function.
|
||||
|
||||
> :book: If you want to use the Promise API, use `util.promisify`.
|
||||
|
||||
```ts
|
||||
fsWalk.walk('path', (error, entries) => { /* … */ });
|
||||
fsWalk.walk('path', {}, (error, entries) => { /* … */ });
|
||||
fsWalk.walk('path', new fsWalk.Settings(), (error, entries) => { /* … */ });
|
||||
```
|
||||
|
||||
### .walkStream(path, [optionsOrSettings])
|
||||
|
||||
Reads the directory recursively and asynchronously. [Readable Stream](https://nodejs.org/dist/latest-v12.x/docs/api/stream.html#stream_readable_streams) is used as a provider.
|
||||
|
||||
```ts
|
||||
const stream = fsWalk.walkStream('path');
|
||||
const stream = fsWalk.walkStream('path', {});
|
||||
const stream = fsWalk.walkStream('path', new fsWalk.Settings());
|
||||
```
|
||||
|
||||
### .walkSync(path, [optionsOrSettings])
|
||||
|
||||
Reads the directory recursively and synchronously. Returns an array of entries.
|
||||
|
||||
```ts
|
||||
const entries = fsWalk.walkSync('path');
|
||||
const entries = fsWalk.walkSync('path', {});
|
||||
const entries = fsWalk.walkSync('path', new fsWalk.Settings());
|
||||
```
|
||||
|
||||
#### path
|
||||
|
||||
* Required: `true`
|
||||
* Type: `string | Buffer | URL`
|
||||
|
||||
A path to a file. If a URL is provided, it must use the `file:` protocol.
|
||||
|
||||
#### optionsOrSettings
|
||||
|
||||
* Required: `false`
|
||||
* Type: `Options | Settings`
|
||||
* Default: An instance of `Settings` class
|
||||
|
||||
An [`Options`](#options) object or an instance of [`Settings`](#settings) class.
|
||||
|
||||
> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
|
||||
|
||||
### Settings([options])
|
||||
|
||||
A class of full settings of the package.
|
||||
|
||||
```ts
|
||||
const settings = new fsWalk.Settings({ followSymbolicLinks: true });
|
||||
|
||||
const entries = fsWalk.walkSync('path', settings);
|
||||
```
|
||||
|
||||
## Entry
|
||||
|
||||
* `name` — The name of the entry (`unknown.txt`).
|
||||
* `path` — The path of the entry relative to call directory (`root/unknown.txt`).
|
||||
* `dirent` — An instance of [`fs.Dirent`](./src/types/index.ts) class.
|
||||
* [`stats`] — An instance of `fs.Stats` class.
|
||||
|
||||
## Options
|
||||
|
||||
### basePath
|
||||
|
||||
* Type: `string`
|
||||
* Default: `undefined`
|
||||
|
||||
By default, all paths are built relative to the root path. You can use this option to set custom root path.
|
||||
|
||||
In the example below we read the files from the `root` directory, but in the results the root path will be `custom`.
|
||||
|
||||
```ts
|
||||
fsWalk.walkSync('root'); // → ['root/file.txt']
|
||||
fsWalk.walkSync('root', { basePath: 'custom' }); // → ['custom/file.txt']
|
||||
```
|
||||
|
||||
### concurrency
|
||||
|
||||
* Type: `number`
|
||||
* Default: `Infinity`
|
||||
|
||||
The maximum number of concurrent calls to `fs.readdir`.
|
||||
|
||||
> :book: The higher the number, the higher performance and the load on the File System. If you want to read in quiet mode, set the value to `4 * os.cpus().length` (4 is default size of [thread pool work scheduling](http://docs.libuv.org/en/v1.x/threadpool.html#thread-pool-work-scheduling)).
|
||||
|
||||
### deepFilter
|
||||
|
||||
* Type: [`DeepFilterFunction`](./src/settings.ts)
|
||||
* Default: `undefined`
|
||||
|
||||
A function that indicates whether the directory will be read deep or not.
|
||||
|
||||
```ts
|
||||
// Skip all directories that starts with `node_modules`
|
||||
const filter: DeepFilterFunction = (entry) => !entry.path.startsWith('node_modules');
|
||||
```
|
||||
|
||||
### entryFilter
|
||||
|
||||
* Type: [`EntryFilterFunction`](./src/settings.ts)
|
||||
* Default: `undefined`
|
||||
|
||||
A function that indicates whether the entry will be included to results or not.
|
||||
|
||||
```ts
|
||||
// Exclude all `.js` files from results
|
||||
const filter: EntryFilterFunction = (entry) => !entry.name.endsWith('.js');
|
||||
```
|
||||
|
||||
### errorFilter
|
||||
|
||||
* Type: [`ErrorFilterFunction`](./src/settings.ts)
|
||||
* Default: `undefined`
|
||||
|
||||
A function that allows you to skip errors that occur when reading directories.
|
||||
|
||||
For example, you can skip `ENOENT` errors if required:
|
||||
|
||||
```ts
|
||||
// Skip all ENOENT errors
|
||||
const filter: ErrorFilterFunction = (error) => error.code == 'ENOENT';
|
||||
```
|
||||
|
||||
### stats
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Adds an instance of `fs.Stats` class to the [`Entry`](#entry).
|
||||
|
||||
> :book: Always use `fs.readdir` with additional `fs.lstat/fs.stat` calls to determine the entry type.
|
||||
|
||||
### followSymbolicLinks
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `false`
|
||||
|
||||
Follow symbolic links or not. Call `fs.stat` on symbolic link if `true`.
|
||||
|
||||
### `throwErrorOnBrokenSymbolicLink`
|
||||
|
||||
* Type: `boolean`
|
||||
* Default: `true`
|
||||
|
||||
Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
|
||||
|
||||
### `pathSegmentSeparator`
|
||||
|
||||
* Type: `string`
|
||||
* Default: `path.sep`
|
||||
|
||||
By default, this package uses the correct path separator for your OS (`\` on Windows, `/` on Unix-like systems). But you can set this option to any separator character(s) that you want to use instead.
|
||||
|
||||
### `fs`
|
||||
|
||||
* Type: `FileSystemAdapter`
|
||||
* Default: A default FS methods
|
||||
|
||||
By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
|
||||
|
||||
```ts
|
||||
interface FileSystemAdapter {
|
||||
lstat: typeof fs.lstat;
|
||||
stat: typeof fs.stat;
|
||||
lstatSync: typeof fs.lstatSync;
|
||||
statSync: typeof fs.statSync;
|
||||
readdir: typeof fs.readdir;
|
||||
readdirSync: typeof fs.readdirSync;
|
||||
}
|
||||
|
||||
const settings = new fsWalk.Settings({
|
||||
fs: { lstat: fakeLstat }
|
||||
});
|
||||
```
|
||||
|
||||
## Changelog
|
||||
|
||||
See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
|
||||
|
||||
## License
|
||||
|
||||
This software is released under the terms of the MIT license.
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
/// <reference types="node" />
|
||||
import type { Readable } from 'stream';
|
||||
import type { Dirent, FileSystemAdapter } from '@nodelib/fs.scandir';
|
||||
import { AsyncCallback } from './providers/async';
|
||||
import Settings, { DeepFilterFunction, EntryFilterFunction, ErrorFilterFunction, Options } from './settings';
|
||||
import type { Entry } from './types';
|
||||
declare function walk(directory: string, callback: AsyncCallback): void;
|
||||
declare function walk(directory: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
|
||||
declare namespace walk {
|
||||
function __promisify__(directory: string, optionsOrSettings?: Options | Settings): Promise<Entry[]>;
|
||||
}
|
||||
declare function walkSync(directory: string, optionsOrSettings?: Options | Settings): Entry[];
|
||||
declare function walkStream(directory: string, optionsOrSettings?: Options | Settings): Readable;
|
||||
export { walk, walkSync, walkStream, Settings, AsyncCallback, Dirent, Entry, FileSystemAdapter, Options, DeepFilterFunction, EntryFilterFunction, ErrorFilterFunction };
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Settings = exports.walkStream = exports.walkSync = exports.walk = void 0;
|
||||
const async_1 = require("./providers/async");
|
||||
const stream_1 = require("./providers/stream");
|
||||
const sync_1 = require("./providers/sync");
|
||||
const settings_1 = require("./settings");
|
||||
exports.Settings = settings_1.default;
|
||||
function walk(directory, optionsOrSettingsOrCallback, callback) {
|
||||
if (typeof optionsOrSettingsOrCallback === 'function') {
|
||||
new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
|
||||
return;
|
||||
}
|
||||
new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
|
||||
}
|
||||
exports.walk = walk;
|
||||
function walkSync(directory, optionsOrSettings) {
|
||||
const settings = getSettings(optionsOrSettings);
|
||||
const provider = new sync_1.default(directory, settings);
|
||||
return provider.read();
|
||||
}
|
||||
exports.walkSync = walkSync;
|
||||
function walkStream(directory, optionsOrSettings) {
|
||||
const settings = getSettings(optionsOrSettings);
|
||||
const provider = new stream_1.default(directory, settings);
|
||||
return provider.read();
|
||||
}
|
||||
exports.walkStream = walkStream;
|
||||
function getSettings(settingsOrOptions = {}) {
|
||||
if (settingsOrOptions instanceof settings_1.default) {
|
||||
return settingsOrOptions;
|
||||
}
|
||||
return new settings_1.default(settingsOrOptions);
|
||||
}
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
import AsyncReader from '../readers/async';
|
||||
import type Settings from '../settings';
|
||||
import type { Entry, Errno } from '../types';
|
||||
export declare type AsyncCallback = (error: Errno, entries: Entry[]) => void;
|
||||
export default class AsyncProvider {
|
||||
private readonly _root;
|
||||
private readonly _settings;
|
||||
protected readonly _reader: AsyncReader;
|
||||
private readonly _storage;
|
||||
constructor(_root: string, _settings: Settings);
|
||||
read(callback: AsyncCallback): void;
|
||||
}
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const async_1 = require("../readers/async");
|
||||
class AsyncProvider {
|
||||
constructor(_root, _settings) {
|
||||
this._root = _root;
|
||||
this._settings = _settings;
|
||||
this._reader = new async_1.default(this._root, this._settings);
|
||||
this._storage = [];
|
||||
}
|
||||
read(callback) {
|
||||
this._reader.onError((error) => {
|
||||
callFailureCallback(callback, error);
|
||||
});
|
||||
this._reader.onEntry((entry) => {
|
||||
this._storage.push(entry);
|
||||
});
|
||||
this._reader.onEnd(() => {
|
||||
callSuccessCallback(callback, this._storage);
|
||||
});
|
||||
this._reader.read();
|
||||
}
|
||||
}
|
||||
exports.default = AsyncProvider;
|
||||
function callFailureCallback(callback, error) {
|
||||
callback(error);
|
||||
}
|
||||
function callSuccessCallback(callback, entries) {
|
||||
callback(null, entries);
|
||||
}
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
import AsyncProvider from './async';
|
||||
import StreamProvider from './stream';
|
||||
import SyncProvider from './sync';
|
||||
export { AsyncProvider, StreamProvider, SyncProvider };
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.SyncProvider = exports.StreamProvider = exports.AsyncProvider = void 0;
|
||||
const async_1 = require("./async");
|
||||
exports.AsyncProvider = async_1.default;
|
||||
const stream_1 = require("./stream");
|
||||
exports.StreamProvider = stream_1.default;
|
||||
const sync_1 = require("./sync");
|
||||
exports.SyncProvider = sync_1.default;
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
/// <reference types="node" />
|
||||
import { Readable } from 'stream';
|
||||
import AsyncReader from '../readers/async';
|
||||
import type Settings from '../settings';
|
||||
export default class StreamProvider {
|
||||
private readonly _root;
|
||||
private readonly _settings;
|
||||
protected readonly _reader: AsyncReader;
|
||||
protected readonly _stream: Readable;
|
||||
constructor(_root: string, _settings: Settings);
|
||||
read(): Readable;
|
||||
}
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const stream_1 = require("stream");
|
||||
const async_1 = require("../readers/async");
|
||||
class StreamProvider {
|
||||
constructor(_root, _settings) {
|
||||
this._root = _root;
|
||||
this._settings = _settings;
|
||||
this._reader = new async_1.default(this._root, this._settings);
|
||||
this._stream = new stream_1.Readable({
|
||||
objectMode: true,
|
||||
read: () => { },
|
||||
destroy: () => {
|
||||
if (!this._reader.isDestroyed) {
|
||||
this._reader.destroy();
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
read() {
|
||||
this._reader.onError((error) => {
|
||||
this._stream.emit('error', error);
|
||||
});
|
||||
this._reader.onEntry((entry) => {
|
||||
this._stream.push(entry);
|
||||
});
|
||||
this._reader.onEnd(() => {
|
||||
this._stream.push(null);
|
||||
});
|
||||
this._reader.read();
|
||||
return this._stream;
|
||||
}
|
||||
}
|
||||
exports.default = StreamProvider;
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
import SyncReader from '../readers/sync';
|
||||
import type Settings from '../settings';
|
||||
import type { Entry } from '../types';
|
||||
export default class SyncProvider {
|
||||
private readonly _root;
|
||||
private readonly _settings;
|
||||
protected readonly _reader: SyncReader;
|
||||
constructor(_root: string, _settings: Settings);
|
||||
read(): Entry[];
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const sync_1 = require("../readers/sync");
|
||||
class SyncProvider {
|
||||
constructor(_root, _settings) {
|
||||
this._root = _root;
|
||||
this._settings = _settings;
|
||||
this._reader = new sync_1.default(this._root, this._settings);
|
||||
}
|
||||
read() {
|
||||
return this._reader.read();
|
||||
}
|
||||
}
|
||||
exports.default = SyncProvider;
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
/// <reference types="node" />
|
||||
import { EventEmitter } from 'events';
|
||||
import * as fsScandir from '@nodelib/fs.scandir';
|
||||
import type Settings from '../settings';
|
||||
import type { Entry, Errno } from '../types';
|
||||
import Reader from './reader';
|
||||
declare type EntryEventCallback = (entry: Entry) => void;
|
||||
declare type ErrorEventCallback = (error: Errno) => void;
|
||||
declare type EndEventCallback = () => void;
|
||||
export default class AsyncReader extends Reader {
|
||||
protected readonly _settings: Settings;
|
||||
protected readonly _scandir: typeof fsScandir.scandir;
|
||||
protected readonly _emitter: EventEmitter;
|
||||
private readonly _queue;
|
||||
private _isFatalError;
|
||||
private _isDestroyed;
|
||||
constructor(_root: string, _settings: Settings);
|
||||
read(): EventEmitter;
|
||||
get isDestroyed(): boolean;
|
||||
destroy(): void;
|
||||
onEntry(callback: EntryEventCallback): void;
|
||||
onError(callback: ErrorEventCallback): void;
|
||||
onEnd(callback: EndEventCallback): void;
|
||||
private _pushToQueue;
|
||||
private _worker;
|
||||
private _handleError;
|
||||
private _handleEntry;
|
||||
private _emitEntry;
|
||||
}
|
||||
export {};
|
||||
|
|
@ -1,97 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const events_1 = require("events");
|
||||
const fsScandir = require("@nodelib/fs.scandir");
|
||||
const fastq = require("fastq");
|
||||
const common = require("./common");
|
||||
const reader_1 = require("./reader");
|
||||
class AsyncReader extends reader_1.default {
|
||||
constructor(_root, _settings) {
|
||||
super(_root, _settings);
|
||||
this._settings = _settings;
|
||||
this._scandir = fsScandir.scandir;
|
||||
this._emitter = new events_1.EventEmitter();
|
||||
this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
|
||||
this._isFatalError = false;
|
||||
this._isDestroyed = false;
|
||||
this._queue.drain = () => {
|
||||
if (!this._isFatalError) {
|
||||
this._emitter.emit('end');
|
||||
}
|
||||
};
|
||||
}
|
||||
read() {
|
||||
this._isFatalError = false;
|
||||
this._isDestroyed = false;
|
||||
setImmediate(() => {
|
||||
this._pushToQueue(this._root, this._settings.basePath);
|
||||
});
|
||||
return this._emitter;
|
||||
}
|
||||
get isDestroyed() {
|
||||
return this._isDestroyed;
|
||||
}
|
||||
destroy() {
|
||||
if (this._isDestroyed) {
|
||||
throw new Error('The reader is already destroyed');
|
||||
}
|
||||
this._isDestroyed = true;
|
||||
this._queue.killAndDrain();
|
||||
}
|
||||
onEntry(callback) {
|
||||
this._emitter.on('entry', callback);
|
||||
}
|
||||
onError(callback) {
|
||||
this._emitter.once('error', callback);
|
||||
}
|
||||
onEnd(callback) {
|
||||
this._emitter.once('end', callback);
|
||||
}
|
||||
_pushToQueue(directory, base) {
|
||||
const queueItem = { directory, base };
|
||||
this._queue.push(queueItem, (error) => {
|
||||
if (error !== null) {
|
||||
this._handleError(error);
|
||||
}
|
||||
});
|
||||
}
|
||||
_worker(item, done) {
|
||||
this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
|
||||
if (error !== null) {
|
||||
done(error, undefined);
|
||||
return;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
this._handleEntry(entry, item.base);
|
||||
}
|
||||
done(null, undefined);
|
||||
});
|
||||
}
|
||||
_handleError(error) {
|
||||
if (this._isDestroyed || !common.isFatalError(this._settings, error)) {
|
||||
return;
|
||||
}
|
||||
this._isFatalError = true;
|
||||
this._isDestroyed = true;
|
||||
this._emitter.emit('error', error);
|
||||
}
|
||||
_handleEntry(entry, base) {
|
||||
if (this._isDestroyed || this._isFatalError) {
|
||||
return;
|
||||
}
|
||||
const fullpath = entry.path;
|
||||
if (base !== undefined) {
|
||||
entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
|
||||
}
|
||||
if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
|
||||
this._emitEntry(entry);
|
||||
}
|
||||
if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
|
||||
this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
|
||||
}
|
||||
}
|
||||
_emitEntry(entry) {
|
||||
this._emitter.emit('entry', entry);
|
||||
}
|
||||
}
|
||||
exports.default = AsyncReader;
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
import type { FilterFunction } from '../settings';
|
||||
import type Settings from '../settings';
|
||||
import type { Errno } from '../types';
|
||||
export declare function isFatalError(settings: Settings, error: Errno): boolean;
|
||||
export declare function isAppliedFilter<T>(filter: FilterFunction<T> | null, value: T): boolean;
|
||||
export declare function replacePathSegmentSeparator(filepath: string, separator: string): string;
|
||||
export declare function joinPathSegments(a: string, b: string, separator: string): string;
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.joinPathSegments = exports.replacePathSegmentSeparator = exports.isAppliedFilter = exports.isFatalError = void 0;
|
||||
function isFatalError(settings, error) {
|
||||
if (settings.errorFilter === null) {
|
||||
return true;
|
||||
}
|
||||
return !settings.errorFilter(error);
|
||||
}
|
||||
exports.isFatalError = isFatalError;
|
||||
function isAppliedFilter(filter, value) {
|
||||
return filter === null || filter(value);
|
||||
}
|
||||
exports.isAppliedFilter = isAppliedFilter;
|
||||
function replacePathSegmentSeparator(filepath, separator) {
|
||||
return filepath.split(/[/\\]/).join(separator);
|
||||
}
|
||||
exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
|
||||
function joinPathSegments(a, b, separator) {
|
||||
if (a === '') {
|
||||
return b;
|
||||
}
|
||||
/**
|
||||
* The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
|
||||
*/
|
||||
if (a.endsWith(separator)) {
|
||||
return a + b;
|
||||
}
|
||||
return a + separator + b;
|
||||
}
|
||||
exports.joinPathSegments = joinPathSegments;
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
import type Settings from '../settings';
|
||||
export default class Reader {
|
||||
protected readonly _root: string;
|
||||
protected readonly _settings: Settings;
|
||||
constructor(_root: string, _settings: Settings);
|
||||
}
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const common = require("./common");
|
||||
class Reader {
|
||||
constructor(_root, _settings) {
|
||||
this._root = _root;
|
||||
this._settings = _settings;
|
||||
this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
|
||||
}
|
||||
}
|
||||
exports.default = Reader;
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
import * as fsScandir from '@nodelib/fs.scandir';
|
||||
import type { Entry } from '../types';
|
||||
import Reader from './reader';
|
||||
export default class SyncReader extends Reader {
|
||||
protected readonly _scandir: typeof fsScandir.scandirSync;
|
||||
private readonly _storage;
|
||||
private readonly _queue;
|
||||
read(): Entry[];
|
||||
private _pushToQueue;
|
||||
private _handleQueue;
|
||||
private _handleDirectory;
|
||||
private _handleError;
|
||||
private _handleEntry;
|
||||
private _pushToStorage;
|
||||
}
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const fsScandir = require("@nodelib/fs.scandir");
|
||||
const common = require("./common");
|
||||
const reader_1 = require("./reader");
|
||||
class SyncReader extends reader_1.default {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this._scandir = fsScandir.scandirSync;
|
||||
this._storage = [];
|
||||
this._queue = new Set();
|
||||
}
|
||||
read() {
|
||||
this._pushToQueue(this._root, this._settings.basePath);
|
||||
this._handleQueue();
|
||||
return this._storage;
|
||||
}
|
||||
_pushToQueue(directory, base) {
|
||||
this._queue.add({ directory, base });
|
||||
}
|
||||
_handleQueue() {
|
||||
for (const item of this._queue.values()) {
|
||||
this._handleDirectory(item.directory, item.base);
|
||||
}
|
||||
}
|
||||
_handleDirectory(directory, base) {
|
||||
try {
|
||||
const entries = this._scandir(directory, this._settings.fsScandirSettings);
|
||||
for (const entry of entries) {
|
||||
this._handleEntry(entry, base);
|
||||
}
|
||||
}
|
||||
catch (error) {
|
||||
this._handleError(error);
|
||||
}
|
||||
}
|
||||
_handleError(error) {
|
||||
if (!common.isFatalError(this._settings, error)) {
|
||||
return;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
_handleEntry(entry, base) {
|
||||
const fullpath = entry.path;
|
||||
if (base !== undefined) {
|
||||
entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
|
||||
}
|
||||
if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
|
||||
this._pushToStorage(entry);
|
||||
}
|
||||
if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
|
||||
this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
|
||||
}
|
||||
}
|
||||
_pushToStorage(entry) {
|
||||
this._storage.push(entry);
|
||||
}
|
||||
}
|
||||
exports.default = SyncReader;
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
import * as fsScandir from '@nodelib/fs.scandir';
|
||||
import type { Entry, Errno } from './types';
|
||||
export declare type FilterFunction<T> = (value: T) => boolean;
|
||||
export declare type DeepFilterFunction = FilterFunction<Entry>;
|
||||
export declare type EntryFilterFunction = FilterFunction<Entry>;
|
||||
export declare type ErrorFilterFunction = FilterFunction<Errno>;
|
||||
export interface Options {
|
||||
basePath?: string;
|
||||
concurrency?: number;
|
||||
deepFilter?: DeepFilterFunction;
|
||||
entryFilter?: EntryFilterFunction;
|
||||
errorFilter?: ErrorFilterFunction;
|
||||
followSymbolicLinks?: boolean;
|
||||
fs?: Partial<fsScandir.FileSystemAdapter>;
|
||||
pathSegmentSeparator?: string;
|
||||
stats?: boolean;
|
||||
throwErrorOnBrokenSymbolicLink?: boolean;
|
||||
}
|
||||
export default class Settings {
|
||||
private readonly _options;
|
||||
readonly basePath?: string;
|
||||
readonly concurrency: number;
|
||||
readonly deepFilter: DeepFilterFunction | null;
|
||||
readonly entryFilter: EntryFilterFunction | null;
|
||||
readonly errorFilter: ErrorFilterFunction | null;
|
||||
readonly pathSegmentSeparator: string;
|
||||
readonly fsScandirSettings: fsScandir.Settings;
|
||||
constructor(_options?: Options);
|
||||
private _getValue;
|
||||
}
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const path = require("path");
|
||||
const fsScandir = require("@nodelib/fs.scandir");
|
||||
class Settings {
|
||||
constructor(_options = {}) {
|
||||
this._options = _options;
|
||||
this.basePath = this._getValue(this._options.basePath, undefined);
|
||||
this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
|
||||
this.deepFilter = this._getValue(this._options.deepFilter, null);
|
||||
this.entryFilter = this._getValue(this._options.entryFilter, null);
|
||||
this.errorFilter = this._getValue(this._options.errorFilter, null);
|
||||
this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
|
||||
this.fsScandirSettings = new fsScandir.Settings({
|
||||
followSymbolicLinks: this._options.followSymbolicLinks,
|
||||
fs: this._options.fs,
|
||||
pathSegmentSeparator: this._options.pathSegmentSeparator,
|
||||
stats: this._options.stats,
|
||||
throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
|
||||
});
|
||||
}
|
||||
_getValue(option, value) {
|
||||
return option !== null && option !== void 0 ? option : value;
|
||||
}
|
||||
}
|
||||
exports.default = Settings;
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
/// <reference types="node" />
|
||||
import type * as scandir from '@nodelib/fs.scandir';
|
||||
export declare type Entry = scandir.Entry;
|
||||
export declare type Errno = NodeJS.ErrnoException;
|
||||
export interface QueueItem {
|
||||
directory: string;
|
||||
base?: string;
|
||||
}
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
{
|
||||
"name": "@nodelib/fs.walk",
|
||||
"version": "1.2.8",
|
||||
"description": "A library for efficiently walking a directory recursively",
|
||||
"license": "MIT",
|
||||
"repository": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.walk",
|
||||
"keywords": [
|
||||
"NodeLib",
|
||||
"fs",
|
||||
"FileSystem",
|
||||
"file system",
|
||||
"walk",
|
||||
"scanner",
|
||||
"crawler"
|
||||
],
|
||||
"engines": {
|
||||
"node": ">= 8"
|
||||
},
|
||||
"files": [
|
||||
"out/**",
|
||||
"!out/**/*.map",
|
||||
"!out/**/*.spec.*",
|
||||
"!out/**/tests/**"
|
||||
],
|
||||
"main": "out/index.js",
|
||||
"typings": "out/index.d.ts",
|
||||
"scripts": {
|
||||
"clean": "rimraf {tsconfig.tsbuildinfo,out}",
|
||||
"lint": "eslint \"src/**/*.ts\" --cache",
|
||||
"compile": "tsc -b .",
|
||||
"compile:watch": "tsc -p . --watch --sourceMap",
|
||||
"test": "mocha \"out/**/*.spec.js\" -s 0",
|
||||
"build": "npm run clean && npm run compile && npm run lint && npm test",
|
||||
"watch": "npm run clean && npm run compile:watch"
|
||||
},
|
||||
"dependencies": {
|
||||
"@nodelib/fs.scandir": "2.1.5",
|
||||
"fastq": "^1.6.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@nodelib/fs.macchiato": "1.0.4"
|
||||
},
|
||||
"gitHead": "1e5bad48565da2b06b8600e744324ea240bf49d8"
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
MIT License
|
||||
|
||||
Copyright (c) Tailwind Labs, Inc.
|
||||
|
||||
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.
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
<p>
|
||||
<a href="https://tailwindcss.com/docs/typography-plugin#gh-light-mode-only" target="_blank">
|
||||
<img src="./.github/logo-light.svg" alt="Tailwind CSS Typography" width="450" height="70">
|
||||
</a>
|
||||
<a href="https://tailwindcss.com/docs/typography-plugin#gh-dark-mode-only" target="_blank">
|
||||
<img src="./.github/logo-dark.svg" alt="Tailwind CSS Typography" width="450" height="70">
|
||||
</a>
|
||||
</p>
|
||||
|
||||
A plugin that provides a set of `prose` classes you can use to add beautiful typographic defaults to any vanilla HTML you don't control, like HTML rendered from Markdown, or pulled from a CMS.
|
||||
|
||||
---
|
||||
|
||||
## Documentation
|
||||
|
||||
For full documentation, visit [tailwindcss.com/docs/typography-plugin](https://tailwindcss.com/docs/typography-plugin).
|
||||
|
||||
## Community
|
||||
|
||||
For help, discussion about best practices, or any other conversation that would benefit from being searchable:
|
||||
|
||||
[Discuss the Tailwind CSS Typography plugin on GitHub](https://github.com/tailwindlabs/tailwindcss/discussions)
|
||||
|
||||
For casual chit-chat with others using the framework:
|
||||
|
||||
[Join the Tailwind CSS Discord Server](https://tailwindcss.com/discord)
|
||||
|
|
@ -1 +0,0 @@
|
|||
../../../../tailwindcss/lib/cli.js
|
||||
|
|
@ -1 +0,0 @@
|
|||
../../../../tailwindcss/lib/cli.js
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
{
|
||||
"name": "@tailwindcss/typography",
|
||||
"version": "0.5.7",
|
||||
"description": "A Tailwind CSS plugin for automatically styling plain HTML content with beautiful typographic defaults.",
|
||||
"main": "src/index.js",
|
||||
"types": "src/index.d.ts",
|
||||
"files": [
|
||||
"src/*.js",
|
||||
"src/*.d.ts",
|
||||
"dist/"
|
||||
],
|
||||
"repository": "https://github.com/tailwindcss/typography",
|
||||
"license": "MIT",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"prettier": {
|
||||
"printWidth": 100,
|
||||
"semi": false,
|
||||
"singleQuote": true,
|
||||
"trailingComma": "es5"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "jest",
|
||||
"dev": "next dev demo",
|
||||
"build": "next build demo",
|
||||
"export": "next export demo",
|
||||
"start": "next start demo"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"tailwindcss": ">=3.0.0 || insiders"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@mdx-js/loader": "^1.0.19",
|
||||
"@mdx-js/mdx": "^1.6.6",
|
||||
"@next/mdx": "^8.1.0",
|
||||
"autoprefixer": "^10.2.1",
|
||||
"highlight.js": "^10.4.1",
|
||||
"jest": "^26.6.1",
|
||||
"jest-diff": "^27.3.1",
|
||||
"next": "^12.0.1",
|
||||
"postcss": "^8.2.3",
|
||||
"prettier": "^2.1.2",
|
||||
"react": "^17.0.2",
|
||||
"react-dom": "^17.0.2",
|
||||
"tailwindcss": "^3.0.0-alpha.2"
|
||||
},
|
||||
"dependencies": {
|
||||
"lodash.castarray": "^4.4.0",
|
||||
"lodash.isplainobject": "^4.0.6",
|
||||
"lodash.merge": "^4.6.2",
|
||||
"postcss-selector-parser": "6.0.10"
|
||||
},
|
||||
"jest": {
|
||||
"setupFilesAfterEnv": [
|
||||
"<rootDir>/jest/customMatchers.js"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
declare function plugin(options?: Partial<{ className: string; target: 'modern' | 'legacy' }>): {
|
||||
handler: () => void
|
||||
}
|
||||
|
||||
declare namespace plugin {
|
||||
const __isOptionsFunction: true
|
||||
}
|
||||
|
||||
export = plugin
|
||||
|
|
@ -1,136 +0,0 @@
|
|||
const plugin = require('tailwindcss/plugin')
|
||||
const merge = require('lodash.merge')
|
||||
const castArray = require('lodash.castarray')
|
||||
const styles = require('./styles')
|
||||
const { commonTrailingPseudos } = require('./utils')
|
||||
|
||||
const computed = {
|
||||
// Reserved for future "magic properties", for example:
|
||||
// bulletColor: (color) => ({ 'ul > li::before': { backgroundColor: color } }),
|
||||
}
|
||||
|
||||
function inWhere(selector, { className, prefix }) {
|
||||
let prefixedNot = prefix(`.not-${className}`).slice(1)
|
||||
let selectorPrefix = selector.startsWith('>') ? `.${className} ` : ''
|
||||
|
||||
// Parse the selector, if every component ends in the same pseudo element(s) then move it to the end
|
||||
let [trailingPseudo, rebuiltSelector] = commonTrailingPseudos(selector)
|
||||
|
||||
if (trailingPseudo) {
|
||||
return `:where(${selectorPrefix}${rebuiltSelector}):not(:where([class~="${prefixedNot}"] *))${trailingPseudo}`
|
||||
}
|
||||
|
||||
return `:where(${selectorPrefix}${selector}):not(:where([class~="${prefixedNot}"] *))`
|
||||
}
|
||||
|
||||
function isObject(value) {
|
||||
return typeof value === 'object' && value !== null
|
||||
}
|
||||
|
||||
function configToCss(config = {}, { target, className, prefix }) {
|
||||
function updateSelector(k, v) {
|
||||
if (target === 'legacy') {
|
||||
return [k, v]
|
||||
}
|
||||
|
||||
if (Array.isArray(v)) {
|
||||
return [k, v]
|
||||
}
|
||||
|
||||
if (isObject(v)) {
|
||||
let nested = Object.values(v).some(isObject)
|
||||
if (nested) {
|
||||
return [
|
||||
inWhere(k, { className, prefix }),
|
||||
v,
|
||||
Object.fromEntries(Object.entries(v).map(([k, v]) => updateSelector(k, v))),
|
||||
]
|
||||
}
|
||||
|
||||
return [inWhere(k, { className, prefix }), v]
|
||||
}
|
||||
|
||||
return [k, v]
|
||||
}
|
||||
|
||||
return Object.fromEntries(
|
||||
Object.entries(
|
||||
merge(
|
||||
{},
|
||||
...Object.keys(config)
|
||||
.filter((key) => computed[key])
|
||||
.map((key) => computed[key](config[key])),
|
||||
...castArray(config.css || {})
|
||||
)
|
||||
).map(([k, v]) => updateSelector(k, v))
|
||||
)
|
||||
}
|
||||
|
||||
module.exports = plugin.withOptions(
|
||||
({ className = 'prose', target = 'modern' } = {}) => {
|
||||
return function ({ addVariant, addComponents, theme, prefix }) {
|
||||
let modifiers = theme('typography')
|
||||
|
||||
let options = { className, prefix }
|
||||
|
||||
for (let [name, ...selectors] of [
|
||||
['headings', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'th'],
|
||||
['h1'],
|
||||
['h2'],
|
||||
['h3'],
|
||||
['h4'],
|
||||
['h5'],
|
||||
['h6'],
|
||||
['p'],
|
||||
['a'],
|
||||
['blockquote'],
|
||||
['figure'],
|
||||
['figcaption'],
|
||||
['strong'],
|
||||
['em'],
|
||||
['code'],
|
||||
['pre'],
|
||||
['ol'],
|
||||
['ul'],
|
||||
['li'],
|
||||
['table'],
|
||||
['thead'],
|
||||
['tr'],
|
||||
['th'],
|
||||
['td'],
|
||||
['img'],
|
||||
['video'],
|
||||
['hr'],
|
||||
['lead', '[class~="lead"]'],
|
||||
]) {
|
||||
selectors = selectors.length === 0 ? [name] : selectors
|
||||
|
||||
let selector =
|
||||
target === 'legacy' ? selectors.map((selector) => `& ${selector}`) : selectors.join(', ')
|
||||
|
||||
addVariant(
|
||||
`${className}-${name}`,
|
||||
target === 'legacy' ? selector : `& :is(${inWhere(selector, options)})`
|
||||
)
|
||||
}
|
||||
|
||||
addComponents(
|
||||
Object.keys(modifiers).map((modifier) => ({
|
||||
[modifier === 'DEFAULT' ? `.${className}` : `.${className}-${modifier}`]: configToCss(
|
||||
modifiers[modifier],
|
||||
{
|
||||
target,
|
||||
className,
|
||||
prefix,
|
||||
}
|
||||
),
|
||||
}))
|
||||
)
|
||||
}
|
||||
},
|
||||
() => {
|
||||
return {
|
||||
theme: { typography: styles },
|
||||
}
|
||||
}
|
||||
)
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -1,62 +0,0 @@
|
|||
const isPlainObject = require('lodash.isplainobject')
|
||||
|
||||
const parser = require('postcss-selector-parser')
|
||||
const parseSelector = parser()
|
||||
|
||||
module.exports = {
|
||||
isUsableColor(color, values) {
|
||||
return isPlainObject(values) && color !== 'gray' && values[600]
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {string} selector
|
||||
*/
|
||||
commonTrailingPseudos(selector) {
|
||||
let ast = parseSelector.astSync(selector)
|
||||
|
||||
/** @type {import('postcss-selector-parser').Pseudo[][]} */
|
||||
let matrix = []
|
||||
|
||||
// Put the pseudo elements in reverse order in a sparse, column-major 2D array
|
||||
for (let [i, sel] of ast.nodes.entries()) {
|
||||
for (const [j, child] of [...sel.nodes].reverse().entries()) {
|
||||
// We only care about pseudo elements
|
||||
if (child.type !== 'pseudo' || !child.value.startsWith('::')) {
|
||||
break
|
||||
}
|
||||
|
||||
matrix[j] = matrix[j] || []
|
||||
matrix[j][i] = child
|
||||
}
|
||||
}
|
||||
|
||||
let trailingPseudos = parser.selector()
|
||||
|
||||
// At this point the pseudo elements are in a column-major 2D array
|
||||
// This means each row contains one "column" of pseudo elements from each selector
|
||||
// We can compare all the pseudo elements in a row to see if they are the same
|
||||
for (const pseudos of matrix) {
|
||||
// It's a sparse 2D array so there are going to be holes in the rows
|
||||
// We skip those
|
||||
if (!pseudos) {
|
||||
continue
|
||||
}
|
||||
|
||||
let values = new Set([...pseudos.map((p) => p.value)])
|
||||
|
||||
// The pseudo elements are not the same
|
||||
if (values.size > 1) {
|
||||
break
|
||||
}
|
||||
|
||||
pseudos.forEach((pseudo) => pseudo.remove())
|
||||
trailingPseudos.prepend(pseudos[0])
|
||||
}
|
||||
|
||||
if (trailingPseudos.nodes.length) {
|
||||
return [trailingPseudos.toString(), ast.toString()]
|
||||
}
|
||||
|
||||
return [null, selector]
|
||||
},
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2018-present, Yuxi (Evan) You
|
||||
|
||||
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.
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
# @vue/reactivity
|
||||
|
||||
## Usage Note
|
||||
|
||||
This package is inlined into Global & Browser ESM builds of user-facing renderers (e.g. `@vue/runtime-dom`), but also published as a package that can be used standalone. The standalone build should not be used alongside a pre-bundled build of a user-facing renderer, as they will have different internal storage for reactivity connections. A user-facing renderer should re-export all APIs from this package.
|
||||
|
||||
For full exposed APIs, see `src/index.ts`. You can also run `yarn build reactivity --types` from repo root, which will generate an API report at `temp/reactivity.api.md`.
|
||||
|
||||
## Credits
|
||||
|
||||
The implementation of this module is inspired by the following prior art in the JavaScript ecosystem:
|
||||
|
||||
- [Meteor Tracker](https://docs.meteor.com/api/tracker.html)
|
||||
- [nx-js/observer-util](https://github.com/nx-js/observer-util)
|
||||
- [salesforce/observable-membrane](https://github.com/salesforce/observable-membrane)
|
||||
|
||||
## Caveats
|
||||
|
||||
- Built-in objects are not observed except for `Array`, `Map`, `WeakMap`, `Set` and `WeakSet`.
|
||||
|
|
@ -1,932 +0,0 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
var shared = require('@vue/shared');
|
||||
|
||||
const targetMap = new WeakMap();
|
||||
const effectStack = [];
|
||||
let activeEffect;
|
||||
const ITERATE_KEY = Symbol('iterate' );
|
||||
const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
|
||||
function isEffect(fn) {
|
||||
return fn && fn._isEffect === true;
|
||||
}
|
||||
function effect(fn, options = shared.EMPTY_OBJ) {
|
||||
if (isEffect(fn)) {
|
||||
fn = fn.raw;
|
||||
}
|
||||
const effect = createReactiveEffect(fn, options);
|
||||
if (!options.lazy) {
|
||||
effect();
|
||||
}
|
||||
return effect;
|
||||
}
|
||||
function stop(effect) {
|
||||
if (effect.active) {
|
||||
cleanup(effect);
|
||||
if (effect.options.onStop) {
|
||||
effect.options.onStop();
|
||||
}
|
||||
effect.active = false;
|
||||
}
|
||||
}
|
||||
let uid = 0;
|
||||
function createReactiveEffect(fn, options) {
|
||||
const effect = function reactiveEffect() {
|
||||
if (!effect.active) {
|
||||
return fn();
|
||||
}
|
||||
if (!effectStack.includes(effect)) {
|
||||
cleanup(effect);
|
||||
try {
|
||||
enableTracking();
|
||||
effectStack.push(effect);
|
||||
activeEffect = effect;
|
||||
return fn();
|
||||
}
|
||||
finally {
|
||||
effectStack.pop();
|
||||
resetTracking();
|
||||
activeEffect = effectStack[effectStack.length - 1];
|
||||
}
|
||||
}
|
||||
};
|
||||
effect.id = uid++;
|
||||
effect.allowRecurse = !!options.allowRecurse;
|
||||
effect._isEffect = true;
|
||||
effect.active = true;
|
||||
effect.raw = fn;
|
||||
effect.deps = [];
|
||||
effect.options = options;
|
||||
return effect;
|
||||
}
|
||||
function cleanup(effect) {
|
||||
const { deps } = effect;
|
||||
if (deps.length) {
|
||||
for (let i = 0; i < deps.length; i++) {
|
||||
deps[i].delete(effect);
|
||||
}
|
||||
deps.length = 0;
|
||||
}
|
||||
}
|
||||
let shouldTrack = true;
|
||||
const trackStack = [];
|
||||
function pauseTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = false;
|
||||
}
|
||||
function enableTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = true;
|
||||
}
|
||||
function resetTracking() {
|
||||
const last = trackStack.pop();
|
||||
shouldTrack = last === undefined ? true : last;
|
||||
}
|
||||
function track(target, type, key) {
|
||||
if (!shouldTrack || activeEffect === undefined) {
|
||||
return;
|
||||
}
|
||||
let depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
targetMap.set(target, (depsMap = new Map()));
|
||||
}
|
||||
let dep = depsMap.get(key);
|
||||
if (!dep) {
|
||||
depsMap.set(key, (dep = new Set()));
|
||||
}
|
||||
if (!dep.has(activeEffect)) {
|
||||
dep.add(activeEffect);
|
||||
activeEffect.deps.push(dep);
|
||||
if (activeEffect.options.onTrack) {
|
||||
activeEffect.options.onTrack({
|
||||
effect: activeEffect,
|
||||
target,
|
||||
type,
|
||||
key
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
function trigger(target, type, key, newValue, oldValue, oldTarget) {
|
||||
const depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
// never been tracked
|
||||
return;
|
||||
}
|
||||
const effects = new Set();
|
||||
const add = (effectsToAdd) => {
|
||||
if (effectsToAdd) {
|
||||
effectsToAdd.forEach(effect => {
|
||||
if (effect !== activeEffect || effect.allowRecurse) {
|
||||
effects.add(effect);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
if (type === "clear" /* CLEAR */) {
|
||||
// collection being cleared
|
||||
// trigger all effects for target
|
||||
depsMap.forEach(add);
|
||||
}
|
||||
else if (key === 'length' && shared.isArray(target)) {
|
||||
depsMap.forEach((dep, key) => {
|
||||
if (key === 'length' || key >= newValue) {
|
||||
add(dep);
|
||||
}
|
||||
});
|
||||
}
|
||||
else {
|
||||
// schedule runs for SET | ADD | DELETE
|
||||
if (key !== void 0) {
|
||||
add(depsMap.get(key));
|
||||
}
|
||||
// also run for iteration key on ADD | DELETE | Map.SET
|
||||
switch (type) {
|
||||
case "add" /* ADD */:
|
||||
if (!shared.isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (shared.isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
else if (shared.isIntegerKey(key)) {
|
||||
// new index added to array -> length changes
|
||||
add(depsMap.get('length'));
|
||||
}
|
||||
break;
|
||||
case "delete" /* DELETE */:
|
||||
if (!shared.isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (shared.isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "set" /* SET */:
|
||||
if (shared.isMap(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
const run = (effect) => {
|
||||
if (effect.options.onTrigger) {
|
||||
effect.options.onTrigger({
|
||||
effect,
|
||||
target,
|
||||
key,
|
||||
type,
|
||||
newValue,
|
||||
oldValue,
|
||||
oldTarget
|
||||
});
|
||||
}
|
||||
if (effect.options.scheduler) {
|
||||
effect.options.scheduler(effect);
|
||||
}
|
||||
else {
|
||||
effect();
|
||||
}
|
||||
};
|
||||
effects.forEach(run);
|
||||
}
|
||||
|
||||
const isNonTrackableKeys = /*#__PURE__*/ shared.makeMap(`__proto__,__v_isRef,__isVue`);
|
||||
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
|
||||
.map(key => Symbol[key])
|
||||
.filter(shared.isSymbol));
|
||||
const get = /*#__PURE__*/ createGetter();
|
||||
const shallowGet = /*#__PURE__*/ createGetter(false, true);
|
||||
const readonlyGet = /*#__PURE__*/ createGetter(true);
|
||||
const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
|
||||
const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
|
||||
function createArrayInstrumentations() {
|
||||
const instrumentations = {};
|
||||
['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
const arr = toRaw(this);
|
||||
for (let i = 0, l = this.length; i < l; i++) {
|
||||
track(arr, "get" /* GET */, i + '');
|
||||
}
|
||||
// we run the method using the original args first (which may be reactive)
|
||||
const res = arr[key](...args);
|
||||
if (res === -1 || res === false) {
|
||||
// if that didn't work, run it again using raw values.
|
||||
return arr[key](...args.map(toRaw));
|
||||
}
|
||||
else {
|
||||
return res;
|
||||
}
|
||||
};
|
||||
});
|
||||
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
pauseTracking();
|
||||
const res = toRaw(this)[key].apply(this, args);
|
||||
resetTracking();
|
||||
return res;
|
||||
};
|
||||
});
|
||||
return instrumentations;
|
||||
}
|
||||
function createGetter(isReadonly = false, shallow = false) {
|
||||
return function get(target, key, receiver) {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */ &&
|
||||
receiver ===
|
||||
(isReadonly
|
||||
? shallow
|
||||
? shallowReadonlyMap
|
||||
: readonlyMap
|
||||
: shallow
|
||||
? shallowReactiveMap
|
||||
: reactiveMap).get(target)) {
|
||||
return target;
|
||||
}
|
||||
const targetIsArray = shared.isArray(target);
|
||||
if (!isReadonly && targetIsArray && shared.hasOwn(arrayInstrumentations, key)) {
|
||||
return Reflect.get(arrayInstrumentations, key, receiver);
|
||||
}
|
||||
const res = Reflect.get(target, key, receiver);
|
||||
if (shared.isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
|
||||
return res;
|
||||
}
|
||||
if (!isReadonly) {
|
||||
track(target, "get" /* GET */, key);
|
||||
}
|
||||
if (shallow) {
|
||||
return res;
|
||||
}
|
||||
if (isRef(res)) {
|
||||
// ref unwrapping - does not apply for Array + integer key.
|
||||
const shouldUnwrap = !targetIsArray || !shared.isIntegerKey(key);
|
||||
return shouldUnwrap ? res.value : res;
|
||||
}
|
||||
if (shared.isObject(res)) {
|
||||
// Convert returned value into a proxy as well. we do the isObject check
|
||||
// here to avoid invalid value warning. Also need to lazy access readonly
|
||||
// and reactive here to avoid circular dependency.
|
||||
return isReadonly ? readonly(res) : reactive(res);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
}
|
||||
const set = /*#__PURE__*/ createSetter();
|
||||
const shallowSet = /*#__PURE__*/ createSetter(true);
|
||||
function createSetter(shallow = false) {
|
||||
return function set(target, key, value, receiver) {
|
||||
let oldValue = target[key];
|
||||
if (!shallow) {
|
||||
value = toRaw(value);
|
||||
oldValue = toRaw(oldValue);
|
||||
if (!shared.isArray(target) && isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
const hadKey = shared.isArray(target) && shared.isIntegerKey(key)
|
||||
? Number(key) < target.length
|
||||
: shared.hasOwn(target, key);
|
||||
const result = Reflect.set(target, key, value, receiver);
|
||||
// don't trigger if target is something up in the prototype chain of original
|
||||
if (target === toRaw(receiver)) {
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (shared.hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value, oldValue);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
}
|
||||
function deleteProperty(target, key) {
|
||||
const hadKey = shared.hasOwn(target, key);
|
||||
const oldValue = target[key];
|
||||
const result = Reflect.deleteProperty(target, key);
|
||||
if (result && hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function has(target, key) {
|
||||
const result = Reflect.has(target, key);
|
||||
if (!shared.isSymbol(key) || !builtInSymbols.has(key)) {
|
||||
track(target, "has" /* HAS */, key);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function ownKeys(target) {
|
||||
track(target, "iterate" /* ITERATE */, shared.isArray(target) ? 'length' : ITERATE_KEY);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const mutableHandlers = {
|
||||
get,
|
||||
set,
|
||||
deleteProperty,
|
||||
has,
|
||||
ownKeys
|
||||
};
|
||||
const readonlyHandlers = {
|
||||
get: readonlyGet,
|
||||
set(target, key) {
|
||||
{
|
||||
console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
|
||||
}
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, key) {
|
||||
{
|
||||
console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
const shallowReactiveHandlers = /*#__PURE__*/ shared.extend({}, mutableHandlers, {
|
||||
get: shallowGet,
|
||||
set: shallowSet
|
||||
});
|
||||
// Props handlers are special in the sense that it should not unwrap top-level
|
||||
// refs (in order to allow refs to be explicitly passed down), but should
|
||||
// retain the reactivity of the normal readonly object.
|
||||
const shallowReadonlyHandlers = /*#__PURE__*/ shared.extend({}, readonlyHandlers, {
|
||||
get: shallowReadonlyGet
|
||||
});
|
||||
|
||||
const toReactive = (value) => shared.isObject(value) ? reactive(value) : value;
|
||||
const toReadonly = (value) => shared.isObject(value) ? readonly(value) : value;
|
||||
const toShallow = (value) => value;
|
||||
const getProto = (v) => Reflect.getPrototypeOf(v);
|
||||
function get$1(target, key, isReadonly = false, isShallow = false) {
|
||||
// #1772: readonly(reactive(Map)) should return readonly + reactive version
|
||||
// of the value
|
||||
target = target["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
|
||||
const { has } = getProto(rawTarget);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
if (has.call(rawTarget, key)) {
|
||||
return wrap(target.get(key));
|
||||
}
|
||||
else if (has.call(rawTarget, rawKey)) {
|
||||
return wrap(target.get(rawKey));
|
||||
}
|
||||
else if (target !== rawTarget) {
|
||||
// #3602 readonly(reactive(Map))
|
||||
// ensure that the nested reactive `Map` can do tracking for itself
|
||||
target.get(key);
|
||||
}
|
||||
}
|
||||
function has$1(key, isReadonly = false) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
|
||||
return key === rawKey
|
||||
? target.has(key)
|
||||
: target.has(key) || target.has(rawKey);
|
||||
}
|
||||
function size(target, isReadonly = false) {
|
||||
target = target["__v_raw" /* RAW */];
|
||||
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return Reflect.get(target, 'size', target);
|
||||
}
|
||||
function add(value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const proto = getProto(target);
|
||||
const hadKey = proto.has.call(target, value);
|
||||
if (!hadKey) {
|
||||
target.add(value);
|
||||
trigger(target, "add" /* ADD */, value, value);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function set$1(key, value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
else {
|
||||
checkIdentityKeys(target, has, key);
|
||||
}
|
||||
const oldValue = get.call(target, key);
|
||||
target.set(key, value);
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (shared.hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value, oldValue);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function deleteEntry(key) {
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
else {
|
||||
checkIdentityKeys(target, has, key);
|
||||
}
|
||||
const oldValue = get ? get.call(target, key) : undefined;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.delete(key);
|
||||
if (hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function clear() {
|
||||
const target = toRaw(this);
|
||||
const hadItems = target.size !== 0;
|
||||
const oldTarget = shared.isMap(target)
|
||||
? new Map(target)
|
||||
: new Set(target)
|
||||
;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.clear();
|
||||
if (hadItems) {
|
||||
trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function createForEach(isReadonly, isShallow) {
|
||||
return function forEach(callback, thisArg) {
|
||||
const observed = this;
|
||||
const target = observed["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return target.forEach((value, key) => {
|
||||
// important: make sure the callback is
|
||||
// 1. invoked with the reactive map as `this` and 3rd arg
|
||||
// 2. the value received should be a corresponding reactive/readonly.
|
||||
return callback.call(thisArg, wrap(value), wrap(key), observed);
|
||||
});
|
||||
};
|
||||
}
|
||||
function createIterableMethod(method, isReadonly, isShallow) {
|
||||
return function (...args) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const targetIsMap = shared.isMap(rawTarget);
|
||||
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
|
||||
const isKeyOnly = method === 'keys' && targetIsMap;
|
||||
const innerIterator = target[method](...args);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly &&
|
||||
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
|
||||
// return a wrapped iterator which returns observed versions of the
|
||||
// values emitted from the real iterator
|
||||
return {
|
||||
// iterator protocol
|
||||
next() {
|
||||
const { value, done } = innerIterator.next();
|
||||
return done
|
||||
? { value, done }
|
||||
: {
|
||||
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
|
||||
done
|
||||
};
|
||||
},
|
||||
// iterable protocol
|
||||
[Symbol.iterator]() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
function createReadonlyMethod(type) {
|
||||
return function (...args) {
|
||||
{
|
||||
const key = args[0] ? `on key "${args[0]}" ` : ``;
|
||||
console.warn(`${shared.capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
|
||||
}
|
||||
return type === "delete" /* DELETE */ ? false : this;
|
||||
};
|
||||
}
|
||||
function createInstrumentations() {
|
||||
const mutableInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, false)
|
||||
};
|
||||
const shallowInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, false, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, true)
|
||||
};
|
||||
const readonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, false)
|
||||
};
|
||||
const shallowReadonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, true)
|
||||
};
|
||||
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
|
||||
iteratorMethods.forEach(method => {
|
||||
mutableInstrumentations[method] = createIterableMethod(method, false, false);
|
||||
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
|
||||
shallowInstrumentations[method] = createIterableMethod(method, false, true);
|
||||
shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
|
||||
});
|
||||
return [
|
||||
mutableInstrumentations,
|
||||
readonlyInstrumentations,
|
||||
shallowInstrumentations,
|
||||
shallowReadonlyInstrumentations
|
||||
];
|
||||
}
|
||||
const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
|
||||
function createInstrumentationGetter(isReadonly, shallow) {
|
||||
const instrumentations = shallow
|
||||
? isReadonly
|
||||
? shallowReadonlyInstrumentations
|
||||
: shallowInstrumentations
|
||||
: isReadonly
|
||||
? readonlyInstrumentations
|
||||
: mutableInstrumentations;
|
||||
return (target, key, receiver) => {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */) {
|
||||
return target;
|
||||
}
|
||||
return Reflect.get(shared.hasOwn(instrumentations, key) && key in target
|
||||
? instrumentations
|
||||
: target, key, receiver);
|
||||
};
|
||||
}
|
||||
const mutableCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, false)
|
||||
};
|
||||
const shallowCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, true)
|
||||
};
|
||||
const readonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, false)
|
||||
};
|
||||
const shallowReadonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, true)
|
||||
};
|
||||
function checkIdentityKeys(target, has, key) {
|
||||
const rawKey = toRaw(key);
|
||||
if (rawKey !== key && has.call(target, rawKey)) {
|
||||
const type = shared.toRawType(target);
|
||||
console.warn(`Reactive ${type} contains both the raw and reactive ` +
|
||||
`versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
|
||||
`which can lead to inconsistencies. ` +
|
||||
`Avoid differentiating between the raw and reactive versions ` +
|
||||
`of an object and only use the reactive version if possible.`);
|
||||
}
|
||||
}
|
||||
|
||||
const reactiveMap = new WeakMap();
|
||||
const shallowReactiveMap = new WeakMap();
|
||||
const readonlyMap = new WeakMap();
|
||||
const shallowReadonlyMap = new WeakMap();
|
||||
function targetTypeMap(rawType) {
|
||||
switch (rawType) {
|
||||
case 'Object':
|
||||
case 'Array':
|
||||
return 1 /* COMMON */;
|
||||
case 'Map':
|
||||
case 'Set':
|
||||
case 'WeakMap':
|
||||
case 'WeakSet':
|
||||
return 2 /* COLLECTION */;
|
||||
default:
|
||||
return 0 /* INVALID */;
|
||||
}
|
||||
}
|
||||
function getTargetType(value) {
|
||||
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
|
||||
? 0 /* INVALID */
|
||||
: targetTypeMap(shared.toRawType(value));
|
||||
}
|
||||
function reactive(target) {
|
||||
// if trying to observe a readonly proxy, return the readonly version.
|
||||
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
|
||||
return target;
|
||||
}
|
||||
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
|
||||
}
|
||||
/**
|
||||
* Return a shallowly-reactive copy of the original object, where only the root
|
||||
* level properties are reactive. It also does not auto-unwrap refs (even at the
|
||||
* root level).
|
||||
*/
|
||||
function shallowReactive(target) {
|
||||
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
|
||||
}
|
||||
/**
|
||||
* Creates a readonly copy of the original object. Note the returned copy is not
|
||||
* made reactive, but `readonly` can be called on an already reactive object.
|
||||
*/
|
||||
function readonly(target) {
|
||||
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
|
||||
}
|
||||
/**
|
||||
* Returns a reactive-copy of the original object, where only the root level
|
||||
* properties are readonly, and does NOT unwrap refs nor recursively convert
|
||||
* returned properties.
|
||||
* This is used for creating the props proxy object for stateful components.
|
||||
*/
|
||||
function shallowReadonly(target) {
|
||||
return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
|
||||
}
|
||||
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
|
||||
if (!shared.isObject(target)) {
|
||||
{
|
||||
console.warn(`value cannot be made reactive: ${String(target)}`);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
// target is already a Proxy, return it.
|
||||
// exception: calling readonly() on a reactive object
|
||||
if (target["__v_raw" /* RAW */] &&
|
||||
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
|
||||
return target;
|
||||
}
|
||||
// target already has corresponding Proxy
|
||||
const existingProxy = proxyMap.get(target);
|
||||
if (existingProxy) {
|
||||
return existingProxy;
|
||||
}
|
||||
// only a whitelist of value types can be observed.
|
||||
const targetType = getTargetType(target);
|
||||
if (targetType === 0 /* INVALID */) {
|
||||
return target;
|
||||
}
|
||||
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
|
||||
proxyMap.set(target, proxy);
|
||||
return proxy;
|
||||
}
|
||||
function isReactive(value) {
|
||||
if (isReadonly(value)) {
|
||||
return isReactive(value["__v_raw" /* RAW */]);
|
||||
}
|
||||
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
|
||||
}
|
||||
function isReadonly(value) {
|
||||
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
|
||||
}
|
||||
function isProxy(value) {
|
||||
return isReactive(value) || isReadonly(value);
|
||||
}
|
||||
function toRaw(observed) {
|
||||
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
|
||||
}
|
||||
function markRaw(value) {
|
||||
shared.def(value, "__v_skip" /* SKIP */, true);
|
||||
return value;
|
||||
}
|
||||
|
||||
const convert = (val) => shared.isObject(val) ? reactive(val) : val;
|
||||
function isRef(r) {
|
||||
return Boolean(r && r.__v_isRef === true);
|
||||
}
|
||||
function ref(value) {
|
||||
return createRef(value);
|
||||
}
|
||||
function shallowRef(value) {
|
||||
return createRef(value, true);
|
||||
}
|
||||
class RefImpl {
|
||||
constructor(value, _shallow = false) {
|
||||
this._shallow = _shallow;
|
||||
this.__v_isRef = true;
|
||||
this._rawValue = _shallow ? value : toRaw(value);
|
||||
this._value = _shallow ? value : convert(value);
|
||||
}
|
||||
get value() {
|
||||
track(toRaw(this), "get" /* GET */, 'value');
|
||||
return this._value;
|
||||
}
|
||||
set value(newVal) {
|
||||
newVal = this._shallow ? newVal : toRaw(newVal);
|
||||
if (shared.hasChanged(newVal, this._rawValue)) {
|
||||
this._rawValue = newVal;
|
||||
this._value = this._shallow ? newVal : convert(newVal);
|
||||
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
|
||||
}
|
||||
}
|
||||
}
|
||||
function createRef(rawValue, shallow = false) {
|
||||
if (isRef(rawValue)) {
|
||||
return rawValue;
|
||||
}
|
||||
return new RefImpl(rawValue, shallow);
|
||||
}
|
||||
function triggerRef(ref) {
|
||||
trigger(toRaw(ref), "set" /* SET */, 'value', ref.value );
|
||||
}
|
||||
function unref(ref) {
|
||||
return isRef(ref) ? ref.value : ref;
|
||||
}
|
||||
const shallowUnwrapHandlers = {
|
||||
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
|
||||
set: (target, key, value, receiver) => {
|
||||
const oldValue = target[key];
|
||||
if (isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return Reflect.set(target, key, value, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
function proxyRefs(objectWithRefs) {
|
||||
return isReactive(objectWithRefs)
|
||||
? objectWithRefs
|
||||
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
|
||||
}
|
||||
class CustomRefImpl {
|
||||
constructor(factory) {
|
||||
this.__v_isRef = true;
|
||||
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
|
||||
this._get = get;
|
||||
this._set = set;
|
||||
}
|
||||
get value() {
|
||||
return this._get();
|
||||
}
|
||||
set value(newVal) {
|
||||
this._set(newVal);
|
||||
}
|
||||
}
|
||||
function customRef(factory) {
|
||||
return new CustomRefImpl(factory);
|
||||
}
|
||||
function toRefs(object) {
|
||||
if (!isProxy(object)) {
|
||||
console.warn(`toRefs() expects a reactive object but received a plain one.`);
|
||||
}
|
||||
const ret = shared.isArray(object) ? new Array(object.length) : {};
|
||||
for (const key in object) {
|
||||
ret[key] = toRef(object, key);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
class ObjectRefImpl {
|
||||
constructor(_object, _key) {
|
||||
this._object = _object;
|
||||
this._key = _key;
|
||||
this.__v_isRef = true;
|
||||
}
|
||||
get value() {
|
||||
return this._object[this._key];
|
||||
}
|
||||
set value(newVal) {
|
||||
this._object[this._key] = newVal;
|
||||
}
|
||||
}
|
||||
function toRef(object, key) {
|
||||
return isRef(object[key])
|
||||
? object[key]
|
||||
: new ObjectRefImpl(object, key);
|
||||
}
|
||||
|
||||
class ComputedRefImpl {
|
||||
constructor(getter, _setter, isReadonly) {
|
||||
this._setter = _setter;
|
||||
this._dirty = true;
|
||||
this.__v_isRef = true;
|
||||
this.effect = effect(getter, {
|
||||
lazy: true,
|
||||
scheduler: () => {
|
||||
if (!this._dirty) {
|
||||
this._dirty = true;
|
||||
trigger(toRaw(this), "set" /* SET */, 'value');
|
||||
}
|
||||
}
|
||||
});
|
||||
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
|
||||
}
|
||||
get value() {
|
||||
// the computed ref may get wrapped by other proxies e.g. readonly() #3376
|
||||
const self = toRaw(this);
|
||||
if (self._dirty) {
|
||||
self._value = this.effect();
|
||||
self._dirty = false;
|
||||
}
|
||||
track(self, "get" /* GET */, 'value');
|
||||
return self._value;
|
||||
}
|
||||
set value(newValue) {
|
||||
this._setter(newValue);
|
||||
}
|
||||
}
|
||||
function computed(getterOrOptions) {
|
||||
let getter;
|
||||
let setter;
|
||||
if (shared.isFunction(getterOrOptions)) {
|
||||
getter = getterOrOptions;
|
||||
setter = () => {
|
||||
console.warn('Write operation failed: computed value is readonly');
|
||||
}
|
||||
;
|
||||
}
|
||||
else {
|
||||
getter = getterOrOptions.get;
|
||||
setter = getterOrOptions.set;
|
||||
}
|
||||
return new ComputedRefImpl(getter, setter, shared.isFunction(getterOrOptions) || !getterOrOptions.set);
|
||||
}
|
||||
|
||||
exports.ITERATE_KEY = ITERATE_KEY;
|
||||
exports.computed = computed;
|
||||
exports.customRef = customRef;
|
||||
exports.effect = effect;
|
||||
exports.enableTracking = enableTracking;
|
||||
exports.isProxy = isProxy;
|
||||
exports.isReactive = isReactive;
|
||||
exports.isReadonly = isReadonly;
|
||||
exports.isRef = isRef;
|
||||
exports.markRaw = markRaw;
|
||||
exports.pauseTracking = pauseTracking;
|
||||
exports.proxyRefs = proxyRefs;
|
||||
exports.reactive = reactive;
|
||||
exports.readonly = readonly;
|
||||
exports.ref = ref;
|
||||
exports.resetTracking = resetTracking;
|
||||
exports.shallowReactive = shallowReactive;
|
||||
exports.shallowReadonly = shallowReadonly;
|
||||
exports.shallowRef = shallowRef;
|
||||
exports.stop = stop;
|
||||
exports.toRaw = toRaw;
|
||||
exports.toRef = toRef;
|
||||
exports.toRefs = toRefs;
|
||||
exports.track = track;
|
||||
exports.trigger = trigger;
|
||||
exports.triggerRef = triggerRef;
|
||||
exports.unref = unref;
|
||||
|
|
@ -1,873 +0,0 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
var shared = require('@vue/shared');
|
||||
|
||||
const targetMap = new WeakMap();
|
||||
const effectStack = [];
|
||||
let activeEffect;
|
||||
const ITERATE_KEY = Symbol('');
|
||||
const MAP_KEY_ITERATE_KEY = Symbol('');
|
||||
function isEffect(fn) {
|
||||
return fn && fn._isEffect === true;
|
||||
}
|
||||
function effect(fn, options = shared.EMPTY_OBJ) {
|
||||
if (isEffect(fn)) {
|
||||
fn = fn.raw;
|
||||
}
|
||||
const effect = createReactiveEffect(fn, options);
|
||||
if (!options.lazy) {
|
||||
effect();
|
||||
}
|
||||
return effect;
|
||||
}
|
||||
function stop(effect) {
|
||||
if (effect.active) {
|
||||
cleanup(effect);
|
||||
if (effect.options.onStop) {
|
||||
effect.options.onStop();
|
||||
}
|
||||
effect.active = false;
|
||||
}
|
||||
}
|
||||
let uid = 0;
|
||||
function createReactiveEffect(fn, options) {
|
||||
const effect = function reactiveEffect() {
|
||||
if (!effect.active) {
|
||||
return fn();
|
||||
}
|
||||
if (!effectStack.includes(effect)) {
|
||||
cleanup(effect);
|
||||
try {
|
||||
enableTracking();
|
||||
effectStack.push(effect);
|
||||
activeEffect = effect;
|
||||
return fn();
|
||||
}
|
||||
finally {
|
||||
effectStack.pop();
|
||||
resetTracking();
|
||||
activeEffect = effectStack[effectStack.length - 1];
|
||||
}
|
||||
}
|
||||
};
|
||||
effect.id = uid++;
|
||||
effect.allowRecurse = !!options.allowRecurse;
|
||||
effect._isEffect = true;
|
||||
effect.active = true;
|
||||
effect.raw = fn;
|
||||
effect.deps = [];
|
||||
effect.options = options;
|
||||
return effect;
|
||||
}
|
||||
function cleanup(effect) {
|
||||
const { deps } = effect;
|
||||
if (deps.length) {
|
||||
for (let i = 0; i < deps.length; i++) {
|
||||
deps[i].delete(effect);
|
||||
}
|
||||
deps.length = 0;
|
||||
}
|
||||
}
|
||||
let shouldTrack = true;
|
||||
const trackStack = [];
|
||||
function pauseTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = false;
|
||||
}
|
||||
function enableTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = true;
|
||||
}
|
||||
function resetTracking() {
|
||||
const last = trackStack.pop();
|
||||
shouldTrack = last === undefined ? true : last;
|
||||
}
|
||||
function track(target, type, key) {
|
||||
if (!shouldTrack || activeEffect === undefined) {
|
||||
return;
|
||||
}
|
||||
let depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
targetMap.set(target, (depsMap = new Map()));
|
||||
}
|
||||
let dep = depsMap.get(key);
|
||||
if (!dep) {
|
||||
depsMap.set(key, (dep = new Set()));
|
||||
}
|
||||
if (!dep.has(activeEffect)) {
|
||||
dep.add(activeEffect);
|
||||
activeEffect.deps.push(dep);
|
||||
}
|
||||
}
|
||||
function trigger(target, type, key, newValue, oldValue, oldTarget) {
|
||||
const depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
// never been tracked
|
||||
return;
|
||||
}
|
||||
const effects = new Set();
|
||||
const add = (effectsToAdd) => {
|
||||
if (effectsToAdd) {
|
||||
effectsToAdd.forEach(effect => {
|
||||
if (effect !== activeEffect || effect.allowRecurse) {
|
||||
effects.add(effect);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
if (type === "clear" /* CLEAR */) {
|
||||
// collection being cleared
|
||||
// trigger all effects for target
|
||||
depsMap.forEach(add);
|
||||
}
|
||||
else if (key === 'length' && shared.isArray(target)) {
|
||||
depsMap.forEach((dep, key) => {
|
||||
if (key === 'length' || key >= newValue) {
|
||||
add(dep);
|
||||
}
|
||||
});
|
||||
}
|
||||
else {
|
||||
// schedule runs for SET | ADD | DELETE
|
||||
if (key !== void 0) {
|
||||
add(depsMap.get(key));
|
||||
}
|
||||
// also run for iteration key on ADD | DELETE | Map.SET
|
||||
switch (type) {
|
||||
case "add" /* ADD */:
|
||||
if (!shared.isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (shared.isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
else if (shared.isIntegerKey(key)) {
|
||||
// new index added to array -> length changes
|
||||
add(depsMap.get('length'));
|
||||
}
|
||||
break;
|
||||
case "delete" /* DELETE */:
|
||||
if (!shared.isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (shared.isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "set" /* SET */:
|
||||
if (shared.isMap(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
const run = (effect) => {
|
||||
if (effect.options.scheduler) {
|
||||
effect.options.scheduler(effect);
|
||||
}
|
||||
else {
|
||||
effect();
|
||||
}
|
||||
};
|
||||
effects.forEach(run);
|
||||
}
|
||||
|
||||
const isNonTrackableKeys = /*#__PURE__*/ shared.makeMap(`__proto__,__v_isRef,__isVue`);
|
||||
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
|
||||
.map(key => Symbol[key])
|
||||
.filter(shared.isSymbol));
|
||||
const get = /*#__PURE__*/ createGetter();
|
||||
const shallowGet = /*#__PURE__*/ createGetter(false, true);
|
||||
const readonlyGet = /*#__PURE__*/ createGetter(true);
|
||||
const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
|
||||
const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
|
||||
function createArrayInstrumentations() {
|
||||
const instrumentations = {};
|
||||
['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
const arr = toRaw(this);
|
||||
for (let i = 0, l = this.length; i < l; i++) {
|
||||
track(arr, "get" /* GET */, i + '');
|
||||
}
|
||||
// we run the method using the original args first (which may be reactive)
|
||||
const res = arr[key](...args);
|
||||
if (res === -1 || res === false) {
|
||||
// if that didn't work, run it again using raw values.
|
||||
return arr[key](...args.map(toRaw));
|
||||
}
|
||||
else {
|
||||
return res;
|
||||
}
|
||||
};
|
||||
});
|
||||
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
pauseTracking();
|
||||
const res = toRaw(this)[key].apply(this, args);
|
||||
resetTracking();
|
||||
return res;
|
||||
};
|
||||
});
|
||||
return instrumentations;
|
||||
}
|
||||
function createGetter(isReadonly = false, shallow = false) {
|
||||
return function get(target, key, receiver) {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */ &&
|
||||
receiver ===
|
||||
(isReadonly
|
||||
? shallow
|
||||
? shallowReadonlyMap
|
||||
: readonlyMap
|
||||
: shallow
|
||||
? shallowReactiveMap
|
||||
: reactiveMap).get(target)) {
|
||||
return target;
|
||||
}
|
||||
const targetIsArray = shared.isArray(target);
|
||||
if (!isReadonly && targetIsArray && shared.hasOwn(arrayInstrumentations, key)) {
|
||||
return Reflect.get(arrayInstrumentations, key, receiver);
|
||||
}
|
||||
const res = Reflect.get(target, key, receiver);
|
||||
if (shared.isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
|
||||
return res;
|
||||
}
|
||||
if (!isReadonly) {
|
||||
track(target, "get" /* GET */, key);
|
||||
}
|
||||
if (shallow) {
|
||||
return res;
|
||||
}
|
||||
if (isRef(res)) {
|
||||
// ref unwrapping - does not apply for Array + integer key.
|
||||
const shouldUnwrap = !targetIsArray || !shared.isIntegerKey(key);
|
||||
return shouldUnwrap ? res.value : res;
|
||||
}
|
||||
if (shared.isObject(res)) {
|
||||
// Convert returned value into a proxy as well. we do the isObject check
|
||||
// here to avoid invalid value warning. Also need to lazy access readonly
|
||||
// and reactive here to avoid circular dependency.
|
||||
return isReadonly ? readonly(res) : reactive(res);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
}
|
||||
const set = /*#__PURE__*/ createSetter();
|
||||
const shallowSet = /*#__PURE__*/ createSetter(true);
|
||||
function createSetter(shallow = false) {
|
||||
return function set(target, key, value, receiver) {
|
||||
let oldValue = target[key];
|
||||
if (!shallow) {
|
||||
value = toRaw(value);
|
||||
oldValue = toRaw(oldValue);
|
||||
if (!shared.isArray(target) && isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
const hadKey = shared.isArray(target) && shared.isIntegerKey(key)
|
||||
? Number(key) < target.length
|
||||
: shared.hasOwn(target, key);
|
||||
const result = Reflect.set(target, key, value, receiver);
|
||||
// don't trigger if target is something up in the prototype chain of original
|
||||
if (target === toRaw(receiver)) {
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (shared.hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
}
|
||||
function deleteProperty(target, key) {
|
||||
const hadKey = shared.hasOwn(target, key);
|
||||
target[key];
|
||||
const result = Reflect.deleteProperty(target, key);
|
||||
if (result && hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function has(target, key) {
|
||||
const result = Reflect.has(target, key);
|
||||
if (!shared.isSymbol(key) || !builtInSymbols.has(key)) {
|
||||
track(target, "has" /* HAS */, key);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function ownKeys(target) {
|
||||
track(target, "iterate" /* ITERATE */, shared.isArray(target) ? 'length' : ITERATE_KEY);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const mutableHandlers = {
|
||||
get,
|
||||
set,
|
||||
deleteProperty,
|
||||
has,
|
||||
ownKeys
|
||||
};
|
||||
const readonlyHandlers = {
|
||||
get: readonlyGet,
|
||||
set(target, key) {
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, key) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
const shallowReactiveHandlers = /*#__PURE__*/ shared.extend({}, mutableHandlers, {
|
||||
get: shallowGet,
|
||||
set: shallowSet
|
||||
});
|
||||
// Props handlers are special in the sense that it should not unwrap top-level
|
||||
// refs (in order to allow refs to be explicitly passed down), but should
|
||||
// retain the reactivity of the normal readonly object.
|
||||
const shallowReadonlyHandlers = /*#__PURE__*/ shared.extend({}, readonlyHandlers, {
|
||||
get: shallowReadonlyGet
|
||||
});
|
||||
|
||||
const toReactive = (value) => shared.isObject(value) ? reactive(value) : value;
|
||||
const toReadonly = (value) => shared.isObject(value) ? readonly(value) : value;
|
||||
const toShallow = (value) => value;
|
||||
const getProto = (v) => Reflect.getPrototypeOf(v);
|
||||
function get$1(target, key, isReadonly = false, isShallow = false) {
|
||||
// #1772: readonly(reactive(Map)) should return readonly + reactive version
|
||||
// of the value
|
||||
target = target["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
|
||||
const { has } = getProto(rawTarget);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
if (has.call(rawTarget, key)) {
|
||||
return wrap(target.get(key));
|
||||
}
|
||||
else if (has.call(rawTarget, rawKey)) {
|
||||
return wrap(target.get(rawKey));
|
||||
}
|
||||
else if (target !== rawTarget) {
|
||||
// #3602 readonly(reactive(Map))
|
||||
// ensure that the nested reactive `Map` can do tracking for itself
|
||||
target.get(key);
|
||||
}
|
||||
}
|
||||
function has$1(key, isReadonly = false) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
|
||||
return key === rawKey
|
||||
? target.has(key)
|
||||
: target.has(key) || target.has(rawKey);
|
||||
}
|
||||
function size(target, isReadonly = false) {
|
||||
target = target["__v_raw" /* RAW */];
|
||||
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return Reflect.get(target, 'size', target);
|
||||
}
|
||||
function add(value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const proto = getProto(target);
|
||||
const hadKey = proto.has.call(target, value);
|
||||
if (!hadKey) {
|
||||
target.add(value);
|
||||
trigger(target, "add" /* ADD */, value, value);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function set$1(key, value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
const oldValue = get.call(target, key);
|
||||
target.set(key, value);
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (shared.hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function deleteEntry(key) {
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
get ? get.call(target, key) : undefined;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.delete(key);
|
||||
if (hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function clear() {
|
||||
const target = toRaw(this);
|
||||
const hadItems = target.size !== 0;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.clear();
|
||||
if (hadItems) {
|
||||
trigger(target, "clear" /* CLEAR */, undefined, undefined);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function createForEach(isReadonly, isShallow) {
|
||||
return function forEach(callback, thisArg) {
|
||||
const observed = this;
|
||||
const target = observed["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return target.forEach((value, key) => {
|
||||
// important: make sure the callback is
|
||||
// 1. invoked with the reactive map as `this` and 3rd arg
|
||||
// 2. the value received should be a corresponding reactive/readonly.
|
||||
return callback.call(thisArg, wrap(value), wrap(key), observed);
|
||||
});
|
||||
};
|
||||
}
|
||||
function createIterableMethod(method, isReadonly, isShallow) {
|
||||
return function (...args) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const targetIsMap = shared.isMap(rawTarget);
|
||||
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
|
||||
const isKeyOnly = method === 'keys' && targetIsMap;
|
||||
const innerIterator = target[method](...args);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly &&
|
||||
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
|
||||
// return a wrapped iterator which returns observed versions of the
|
||||
// values emitted from the real iterator
|
||||
return {
|
||||
// iterator protocol
|
||||
next() {
|
||||
const { value, done } = innerIterator.next();
|
||||
return done
|
||||
? { value, done }
|
||||
: {
|
||||
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
|
||||
done
|
||||
};
|
||||
},
|
||||
// iterable protocol
|
||||
[Symbol.iterator]() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
function createReadonlyMethod(type) {
|
||||
return function (...args) {
|
||||
return type === "delete" /* DELETE */ ? false : this;
|
||||
};
|
||||
}
|
||||
function createInstrumentations() {
|
||||
const mutableInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, false)
|
||||
};
|
||||
const shallowInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, false, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, true)
|
||||
};
|
||||
const readonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, false)
|
||||
};
|
||||
const shallowReadonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, true)
|
||||
};
|
||||
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
|
||||
iteratorMethods.forEach(method => {
|
||||
mutableInstrumentations[method] = createIterableMethod(method, false, false);
|
||||
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
|
||||
shallowInstrumentations[method] = createIterableMethod(method, false, true);
|
||||
shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
|
||||
});
|
||||
return [
|
||||
mutableInstrumentations,
|
||||
readonlyInstrumentations,
|
||||
shallowInstrumentations,
|
||||
shallowReadonlyInstrumentations
|
||||
];
|
||||
}
|
||||
const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
|
||||
function createInstrumentationGetter(isReadonly, shallow) {
|
||||
const instrumentations = shallow
|
||||
? isReadonly
|
||||
? shallowReadonlyInstrumentations
|
||||
: shallowInstrumentations
|
||||
: isReadonly
|
||||
? readonlyInstrumentations
|
||||
: mutableInstrumentations;
|
||||
return (target, key, receiver) => {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */) {
|
||||
return target;
|
||||
}
|
||||
return Reflect.get(shared.hasOwn(instrumentations, key) && key in target
|
||||
? instrumentations
|
||||
: target, key, receiver);
|
||||
};
|
||||
}
|
||||
const mutableCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, false)
|
||||
};
|
||||
const shallowCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, true)
|
||||
};
|
||||
const readonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, false)
|
||||
};
|
||||
const shallowReadonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, true)
|
||||
};
|
||||
|
||||
const reactiveMap = new WeakMap();
|
||||
const shallowReactiveMap = new WeakMap();
|
||||
const readonlyMap = new WeakMap();
|
||||
const shallowReadonlyMap = new WeakMap();
|
||||
function targetTypeMap(rawType) {
|
||||
switch (rawType) {
|
||||
case 'Object':
|
||||
case 'Array':
|
||||
return 1 /* COMMON */;
|
||||
case 'Map':
|
||||
case 'Set':
|
||||
case 'WeakMap':
|
||||
case 'WeakSet':
|
||||
return 2 /* COLLECTION */;
|
||||
default:
|
||||
return 0 /* INVALID */;
|
||||
}
|
||||
}
|
||||
function getTargetType(value) {
|
||||
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
|
||||
? 0 /* INVALID */
|
||||
: targetTypeMap(shared.toRawType(value));
|
||||
}
|
||||
function reactive(target) {
|
||||
// if trying to observe a readonly proxy, return the readonly version.
|
||||
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
|
||||
return target;
|
||||
}
|
||||
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
|
||||
}
|
||||
/**
|
||||
* Return a shallowly-reactive copy of the original object, where only the root
|
||||
* level properties are reactive. It also does not auto-unwrap refs (even at the
|
||||
* root level).
|
||||
*/
|
||||
function shallowReactive(target) {
|
||||
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
|
||||
}
|
||||
/**
|
||||
* Creates a readonly copy of the original object. Note the returned copy is not
|
||||
* made reactive, but `readonly` can be called on an already reactive object.
|
||||
*/
|
||||
function readonly(target) {
|
||||
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
|
||||
}
|
||||
/**
|
||||
* Returns a reactive-copy of the original object, where only the root level
|
||||
* properties are readonly, and does NOT unwrap refs nor recursively convert
|
||||
* returned properties.
|
||||
* This is used for creating the props proxy object for stateful components.
|
||||
*/
|
||||
function shallowReadonly(target) {
|
||||
return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
|
||||
}
|
||||
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
|
||||
if (!shared.isObject(target)) {
|
||||
return target;
|
||||
}
|
||||
// target is already a Proxy, return it.
|
||||
// exception: calling readonly() on a reactive object
|
||||
if (target["__v_raw" /* RAW */] &&
|
||||
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
|
||||
return target;
|
||||
}
|
||||
// target already has corresponding Proxy
|
||||
const existingProxy = proxyMap.get(target);
|
||||
if (existingProxy) {
|
||||
return existingProxy;
|
||||
}
|
||||
// only a whitelist of value types can be observed.
|
||||
const targetType = getTargetType(target);
|
||||
if (targetType === 0 /* INVALID */) {
|
||||
return target;
|
||||
}
|
||||
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
|
||||
proxyMap.set(target, proxy);
|
||||
return proxy;
|
||||
}
|
||||
function isReactive(value) {
|
||||
if (isReadonly(value)) {
|
||||
return isReactive(value["__v_raw" /* RAW */]);
|
||||
}
|
||||
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
|
||||
}
|
||||
function isReadonly(value) {
|
||||
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
|
||||
}
|
||||
function isProxy(value) {
|
||||
return isReactive(value) || isReadonly(value);
|
||||
}
|
||||
function toRaw(observed) {
|
||||
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
|
||||
}
|
||||
function markRaw(value) {
|
||||
shared.def(value, "__v_skip" /* SKIP */, true);
|
||||
return value;
|
||||
}
|
||||
|
||||
const convert = (val) => shared.isObject(val) ? reactive(val) : val;
|
||||
function isRef(r) {
|
||||
return Boolean(r && r.__v_isRef === true);
|
||||
}
|
||||
function ref(value) {
|
||||
return createRef(value);
|
||||
}
|
||||
function shallowRef(value) {
|
||||
return createRef(value, true);
|
||||
}
|
||||
class RefImpl {
|
||||
constructor(value, _shallow = false) {
|
||||
this._shallow = _shallow;
|
||||
this.__v_isRef = true;
|
||||
this._rawValue = _shallow ? value : toRaw(value);
|
||||
this._value = _shallow ? value : convert(value);
|
||||
}
|
||||
get value() {
|
||||
track(toRaw(this), "get" /* GET */, 'value');
|
||||
return this._value;
|
||||
}
|
||||
set value(newVal) {
|
||||
newVal = this._shallow ? newVal : toRaw(newVal);
|
||||
if (shared.hasChanged(newVal, this._rawValue)) {
|
||||
this._rawValue = newVal;
|
||||
this._value = this._shallow ? newVal : convert(newVal);
|
||||
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
|
||||
}
|
||||
}
|
||||
}
|
||||
function createRef(rawValue, shallow = false) {
|
||||
if (isRef(rawValue)) {
|
||||
return rawValue;
|
||||
}
|
||||
return new RefImpl(rawValue, shallow);
|
||||
}
|
||||
function triggerRef(ref) {
|
||||
trigger(toRaw(ref), "set" /* SET */, 'value', void 0);
|
||||
}
|
||||
function unref(ref) {
|
||||
return isRef(ref) ? ref.value : ref;
|
||||
}
|
||||
const shallowUnwrapHandlers = {
|
||||
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
|
||||
set: (target, key, value, receiver) => {
|
||||
const oldValue = target[key];
|
||||
if (isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return Reflect.set(target, key, value, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
function proxyRefs(objectWithRefs) {
|
||||
return isReactive(objectWithRefs)
|
||||
? objectWithRefs
|
||||
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
|
||||
}
|
||||
class CustomRefImpl {
|
||||
constructor(factory) {
|
||||
this.__v_isRef = true;
|
||||
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
|
||||
this._get = get;
|
||||
this._set = set;
|
||||
}
|
||||
get value() {
|
||||
return this._get();
|
||||
}
|
||||
set value(newVal) {
|
||||
this._set(newVal);
|
||||
}
|
||||
}
|
||||
function customRef(factory) {
|
||||
return new CustomRefImpl(factory);
|
||||
}
|
||||
function toRefs(object) {
|
||||
const ret = shared.isArray(object) ? new Array(object.length) : {};
|
||||
for (const key in object) {
|
||||
ret[key] = toRef(object, key);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
class ObjectRefImpl {
|
||||
constructor(_object, _key) {
|
||||
this._object = _object;
|
||||
this._key = _key;
|
||||
this.__v_isRef = true;
|
||||
}
|
||||
get value() {
|
||||
return this._object[this._key];
|
||||
}
|
||||
set value(newVal) {
|
||||
this._object[this._key] = newVal;
|
||||
}
|
||||
}
|
||||
function toRef(object, key) {
|
||||
return isRef(object[key])
|
||||
? object[key]
|
||||
: new ObjectRefImpl(object, key);
|
||||
}
|
||||
|
||||
class ComputedRefImpl {
|
||||
constructor(getter, _setter, isReadonly) {
|
||||
this._setter = _setter;
|
||||
this._dirty = true;
|
||||
this.__v_isRef = true;
|
||||
this.effect = effect(getter, {
|
||||
lazy: true,
|
||||
scheduler: () => {
|
||||
if (!this._dirty) {
|
||||
this._dirty = true;
|
||||
trigger(toRaw(this), "set" /* SET */, 'value');
|
||||
}
|
||||
}
|
||||
});
|
||||
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
|
||||
}
|
||||
get value() {
|
||||
// the computed ref may get wrapped by other proxies e.g. readonly() #3376
|
||||
const self = toRaw(this);
|
||||
if (self._dirty) {
|
||||
self._value = this.effect();
|
||||
self._dirty = false;
|
||||
}
|
||||
track(self, "get" /* GET */, 'value');
|
||||
return self._value;
|
||||
}
|
||||
set value(newValue) {
|
||||
this._setter(newValue);
|
||||
}
|
||||
}
|
||||
function computed(getterOrOptions) {
|
||||
let getter;
|
||||
let setter;
|
||||
if (shared.isFunction(getterOrOptions)) {
|
||||
getter = getterOrOptions;
|
||||
setter = shared.NOOP;
|
||||
}
|
||||
else {
|
||||
getter = getterOrOptions.get;
|
||||
setter = getterOrOptions.set;
|
||||
}
|
||||
return new ComputedRefImpl(getter, setter, shared.isFunction(getterOrOptions) || !getterOrOptions.set);
|
||||
}
|
||||
|
||||
exports.ITERATE_KEY = ITERATE_KEY;
|
||||
exports.computed = computed;
|
||||
exports.customRef = customRef;
|
||||
exports.effect = effect;
|
||||
exports.enableTracking = enableTracking;
|
||||
exports.isProxy = isProxy;
|
||||
exports.isReactive = isReactive;
|
||||
exports.isReadonly = isReadonly;
|
||||
exports.isRef = isRef;
|
||||
exports.markRaw = markRaw;
|
||||
exports.pauseTracking = pauseTracking;
|
||||
exports.proxyRefs = proxyRefs;
|
||||
exports.reactive = reactive;
|
||||
exports.readonly = readonly;
|
||||
exports.ref = ref;
|
||||
exports.resetTracking = resetTracking;
|
||||
exports.shallowReactive = shallowReactive;
|
||||
exports.shallowReadonly = shallowReadonly;
|
||||
exports.shallowRef = shallowRef;
|
||||
exports.stop = stop;
|
||||
exports.toRaw = toRaw;
|
||||
exports.toRef = toRef;
|
||||
exports.toRefs = toRefs;
|
||||
exports.track = track;
|
||||
exports.trigger = trigger;
|
||||
exports.triggerRef = triggerRef;
|
||||
exports.unref = unref;
|
||||
|
|
@ -1,323 +0,0 @@
|
|||
|
||||
declare type BaseTypes = string | number | boolean;
|
||||
|
||||
declare type Builtin = Primitive | Function | Date | Error | RegExp;
|
||||
|
||||
declare type CollectionTypes = IterableCollections | WeakCollections;
|
||||
|
||||
export declare function computed<T>(getter: ComputedGetter<T>): ComputedRef<T>;
|
||||
|
||||
export declare function computed<T>(options: WritableComputedOptions<T>): WritableComputedRef<T>;
|
||||
|
||||
export declare type ComputedGetter<T> = (ctx?: any) => T;
|
||||
|
||||
export declare interface ComputedRef<T = any> extends WritableComputedRef<T> {
|
||||
readonly value: T;
|
||||
}
|
||||
|
||||
export declare type ComputedSetter<T> = (v: T) => void;
|
||||
|
||||
export declare function customRef<T>(factory: CustomRefFactory<T>): Ref<T>;
|
||||
|
||||
declare type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
|
||||
get: () => T;
|
||||
set: (value: T) => void;
|
||||
};
|
||||
|
||||
export declare type DebuggerEvent = {
|
||||
effect: ReactiveEffect;
|
||||
target: object;
|
||||
type: TrackOpTypes | TriggerOpTypes;
|
||||
key: any;
|
||||
} & DebuggerEventExtraInfo;
|
||||
|
||||
declare interface DebuggerEventExtraInfo {
|
||||
newValue?: any;
|
||||
oldValue?: any;
|
||||
oldTarget?: Map<any, any> | Set<any>;
|
||||
}
|
||||
|
||||
export declare type DeepReadonly<T> = T extends Builtin ? T : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends WeakMap<infer K, infer V> ? WeakMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends WeakSet<infer U> ? WeakSet<DeepReadonly<U>> : T extends Promise<infer U> ? Promise<DeepReadonly<U>> : T extends {} ? {
|
||||
readonly [K in keyof T]: DeepReadonly<T[K]>;
|
||||
} : Readonly<T>;
|
||||
|
||||
declare type Dep = Set<ReactiveEffect>;
|
||||
|
||||
export declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffect<T>;
|
||||
|
||||
export declare function enableTracking(): void;
|
||||
|
||||
export declare function isProxy(value: unknown): boolean;
|
||||
|
||||
export declare function isReactive(value: unknown): boolean;
|
||||
|
||||
export declare function isReadonly(value: unknown): boolean;
|
||||
|
||||
export declare function isRef<T>(r: Ref<T> | unknown): r is Ref<T>;
|
||||
|
||||
declare type IterableCollections = Map<any, any> | Set<any>;
|
||||
|
||||
export declare const ITERATE_KEY: unique symbol;
|
||||
|
||||
export declare function markRaw<T extends object>(value: T): T;
|
||||
|
||||
export declare function pauseTracking(): void;
|
||||
|
||||
declare type Primitive = string | number | boolean | bigint | symbol | undefined | null;
|
||||
|
||||
export declare function proxyRefs<T extends object>(objectWithRefs: T): ShallowUnwrapRef<T>;
|
||||
|
||||
/**
|
||||
* Creates a reactive copy of the original object.
|
||||
*
|
||||
* The reactive conversion is "deep"—it affects all nested properties. In the
|
||||
* ES2015 Proxy based implementation, the returned proxy is **not** equal to the
|
||||
* original object. It is recommended to work exclusively with the reactive
|
||||
* proxy and avoid relying on the original object.
|
||||
*
|
||||
* A reactive object also automatically unwraps refs contained in it, so you
|
||||
* don't need to use `.value` when accessing and mutating their value:
|
||||
*
|
||||
* ```js
|
||||
* const count = ref(0)
|
||||
* const obj = reactive({
|
||||
* count
|
||||
* })
|
||||
*
|
||||
* obj.count++
|
||||
* obj.count // -> 1
|
||||
* count.value // -> 1
|
||||
* ```
|
||||
*/
|
||||
export declare function reactive<T extends object>(target: T): UnwrapNestedRefs<T>;
|
||||
|
||||
export declare interface ReactiveEffect<T = any> {
|
||||
(): T;
|
||||
_isEffect: true;
|
||||
id: number;
|
||||
active: boolean;
|
||||
raw: () => T;
|
||||
deps: Array<Dep>;
|
||||
options: ReactiveEffectOptions;
|
||||
allowRecurse: boolean;
|
||||
}
|
||||
|
||||
export declare interface ReactiveEffectOptions {
|
||||
lazy?: boolean;
|
||||
scheduler?: (job: ReactiveEffect) => void;
|
||||
onTrack?: (event: DebuggerEvent) => void;
|
||||
onTrigger?: (event: DebuggerEvent) => void;
|
||||
onStop?: () => void;
|
||||
/**
|
||||
* Indicates whether the job is allowed to recursively trigger itself when
|
||||
* managed by the scheduler.
|
||||
*
|
||||
* By default, a job cannot trigger itself because some built-in method calls,
|
||||
* e.g. Array.prototype.push actually performs reads as well (#1740) which
|
||||
* can lead to confusing infinite loops.
|
||||
* The allowed cases are component update functions and watch callbacks.
|
||||
* Component update functions may update child component props, which in turn
|
||||
* trigger flush: "pre" watch callbacks that mutates state that the parent
|
||||
* relies on (#1801). Watch callbacks doesn't track its dependencies so if it
|
||||
* triggers itself again, it's likely intentional and it is the user's
|
||||
* responsibility to perform recursive state mutation that eventually
|
||||
* stabilizes (#1727).
|
||||
*/
|
||||
allowRecurse?: boolean;
|
||||
}
|
||||
|
||||
export declare const enum ReactiveFlags {
|
||||
SKIP = "__v_skip",
|
||||
IS_REACTIVE = "__v_isReactive",
|
||||
IS_READONLY = "__v_isReadonly",
|
||||
RAW = "__v_raw"
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a readonly copy of the original object. Note the returned copy is not
|
||||
* made reactive, but `readonly` can be called on an already reactive object.
|
||||
*/
|
||||
export declare function readonly<T extends object>(target: T): DeepReadonly<UnwrapNestedRefs<T>>;
|
||||
|
||||
export declare interface Ref<T = any> {
|
||||
value: T;
|
||||
/**
|
||||
* Type differentiator only.
|
||||
* We need this to be in public d.ts but don't want it to show up in IDE
|
||||
* autocomplete, so we use a private Symbol instead.
|
||||
*/
|
||||
[RefSymbol]: true;
|
||||
/* Excluded from this release type: _shallow */
|
||||
}
|
||||
|
||||
export declare function ref<T extends object>(value: T): ToRef<T>;
|
||||
|
||||
export declare function ref<T>(value: T): Ref<UnwrapRef<T>>;
|
||||
|
||||
export declare function ref<T = any>(): Ref<T | undefined>;
|
||||
|
||||
declare const RefSymbol: unique symbol;
|
||||
|
||||
/**
|
||||
* This is a special exported interface for other packages to declare
|
||||
* additional types that should bail out for ref unwrapping. For example
|
||||
* \@vue/runtime-dom can declare it like so in its d.ts:
|
||||
*
|
||||
* ``` ts
|
||||
* declare module '@vue/reactivity' {
|
||||
* export interface RefUnwrapBailTypes {
|
||||
* runtimeDOMBailTypes: Node | Window
|
||||
* }
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* Note that api-extractor somehow refuses to include `declare module`
|
||||
* augmentations in its generated d.ts, so we have to manually append them
|
||||
* to the final generated d.ts in our build process.
|
||||
*/
|
||||
export declare interface RefUnwrapBailTypes {
|
||||
}
|
||||
|
||||
export declare function resetTracking(): void;
|
||||
|
||||
/**
|
||||
* Return a shallowly-reactive copy of the original object, where only the root
|
||||
* level properties are reactive. It also does not auto-unwrap refs (even at the
|
||||
* root level).
|
||||
*/
|
||||
export declare function shallowReactive<T extends object>(target: T): T;
|
||||
|
||||
/**
|
||||
* Returns a reactive-copy of the original object, where only the root level
|
||||
* properties are readonly, and does NOT unwrap refs nor recursively convert
|
||||
* returned properties.
|
||||
* This is used for creating the props proxy object for stateful components.
|
||||
*/
|
||||
export declare function shallowReadonly<T extends object>(target: T): Readonly<{
|
||||
[K in keyof T]: UnwrapNestedRefs<T[K]>;
|
||||
}>;
|
||||
|
||||
export declare function shallowRef<T extends object>(value: T): T extends Ref ? T : Ref<T>;
|
||||
|
||||
export declare function shallowRef<T>(value: T): Ref<T>;
|
||||
|
||||
export declare function shallowRef<T = any>(): Ref<T | undefined>;
|
||||
|
||||
export declare type ShallowUnwrapRef<T> = {
|
||||
[K in keyof T]: T[K] extends Ref<infer V> ? V : T[K] extends Ref<infer V> | undefined ? unknown extends V ? undefined : V | undefined : T[K];
|
||||
};
|
||||
|
||||
declare function stop_2(effect: ReactiveEffect): void;
|
||||
export { stop_2 as stop }
|
||||
|
||||
declare type SymbolExtract<T> = (T extends {
|
||||
[Symbol.asyncIterator]: infer V;
|
||||
} ? {
|
||||
[Symbol.asyncIterator]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.hasInstance]: infer V;
|
||||
} ? {
|
||||
[Symbol.hasInstance]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.isConcatSpreadable]: infer V;
|
||||
} ? {
|
||||
[Symbol.isConcatSpreadable]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.iterator]: infer V;
|
||||
} ? {
|
||||
[Symbol.iterator]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.match]: infer V;
|
||||
} ? {
|
||||
[Symbol.match]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.matchAll]: infer V;
|
||||
} ? {
|
||||
[Symbol.matchAll]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.replace]: infer V;
|
||||
} ? {
|
||||
[Symbol.replace]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.search]: infer V;
|
||||
} ? {
|
||||
[Symbol.search]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.species]: infer V;
|
||||
} ? {
|
||||
[Symbol.species]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.split]: infer V;
|
||||
} ? {
|
||||
[Symbol.split]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.toPrimitive]: infer V;
|
||||
} ? {
|
||||
[Symbol.toPrimitive]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.toStringTag]: infer V;
|
||||
} ? {
|
||||
[Symbol.toStringTag]: V;
|
||||
} : {}) & (T extends {
|
||||
[Symbol.unscopables]: infer V;
|
||||
} ? {
|
||||
[Symbol.unscopables]: V;
|
||||
} : {});
|
||||
|
||||
export declare function toRaw<T>(observed: T): T;
|
||||
|
||||
declare type ToRef<T> = [T] extends [Ref] ? T : Ref<UnwrapRef<T>>;
|
||||
|
||||
export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
|
||||
|
||||
export declare type ToRefs<T = any> = {
|
||||
[K in keyof T]: T[K] extends Ref ? T[K] : Ref<UnwrapRef<T[K]>>;
|
||||
};
|
||||
|
||||
export declare function toRefs<T extends object>(object: T): ToRefs<T>;
|
||||
|
||||
export declare function track(target: object, type: TrackOpTypes, key: unknown): void;
|
||||
|
||||
export declare const enum TrackOpTypes {
|
||||
GET = "get",
|
||||
HAS = "has",
|
||||
ITERATE = "iterate"
|
||||
}
|
||||
|
||||
export declare function trigger(target: object, type: TriggerOpTypes, key?: unknown, newValue?: unknown, oldValue?: unknown, oldTarget?: Map<unknown, unknown> | Set<unknown>): void;
|
||||
|
||||
export declare const enum TriggerOpTypes {
|
||||
SET = "set",
|
||||
ADD = "add",
|
||||
DELETE = "delete",
|
||||
CLEAR = "clear"
|
||||
}
|
||||
|
||||
export declare function triggerRef(ref: Ref): void;
|
||||
|
||||
export declare function unref<T>(ref: T | Ref<T>): T;
|
||||
|
||||
export declare type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRef<T>;
|
||||
|
||||
declare type UnwrappedObject<T> = {
|
||||
[P in keyof T]: UnwrapRef<T[P]>;
|
||||
} & SymbolExtract<T>;
|
||||
|
||||
export declare type UnwrapRef<T> = T extends Ref<infer V> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
|
||||
|
||||
declare type UnwrapRefSimple<T> = T extends Function | CollectionTypes | BaseTypes | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] ? T : T extends Array<any> ? {
|
||||
[K in keyof T]: UnwrapRefSimple<T[K]>;
|
||||
} : T extends object ? UnwrappedObject<T> : T;
|
||||
|
||||
declare type WeakCollections = WeakMap<any, any> | WeakSet<any>;
|
||||
|
||||
export declare interface WritableComputedOptions<T> {
|
||||
get: ComputedGetter<T>;
|
||||
set: ComputedSetter<T>;
|
||||
}
|
||||
|
||||
export declare interface WritableComputedRef<T> extends Ref<T> {
|
||||
readonly effect: ReactiveEffect<T>;
|
||||
}
|
||||
|
||||
export { }
|
||||
|
|
@ -1,959 +0,0 @@
|
|||
/**
|
||||
* Make a map and return a function for checking if a key
|
||||
* is in that map.
|
||||
* IMPORTANT: all calls of this function must be prefixed with
|
||||
* \/\*#\_\_PURE\_\_\*\/
|
||||
* So that rollup can tree-shake them if necessary.
|
||||
*/
|
||||
function makeMap(str, expectsLowerCase) {
|
||||
const map = Object.create(null);
|
||||
const list = str.split(',');
|
||||
for (let i = 0; i < list.length; i++) {
|
||||
map[list[i]] = true;
|
||||
}
|
||||
return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
|
||||
}
|
||||
|
||||
const EMPTY_OBJ = Object.freeze({})
|
||||
;
|
||||
Object.freeze([]) ;
|
||||
const extend = Object.assign;
|
||||
const hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
const hasOwn = (val, key) => hasOwnProperty.call(val, key);
|
||||
const isArray = Array.isArray;
|
||||
const isMap = (val) => toTypeString(val) === '[object Map]';
|
||||
const isFunction = (val) => typeof val === 'function';
|
||||
const isString = (val) => typeof val === 'string';
|
||||
const isSymbol = (val) => typeof val === 'symbol';
|
||||
const isObject = (val) => val !== null && typeof val === 'object';
|
||||
const objectToString = Object.prototype.toString;
|
||||
const toTypeString = (value) => objectToString.call(value);
|
||||
const toRawType = (value) => {
|
||||
// extract "RawType" from strings like "[object RawType]"
|
||||
return toTypeString(value).slice(8, -1);
|
||||
};
|
||||
const isIntegerKey = (key) => isString(key) &&
|
||||
key !== 'NaN' &&
|
||||
key[0] !== '-' &&
|
||||
'' + parseInt(key, 10) === key;
|
||||
const cacheStringFunction = (fn) => {
|
||||
const cache = Object.create(null);
|
||||
return ((str) => {
|
||||
const hit = cache[str];
|
||||
return hit || (cache[str] = fn(str));
|
||||
});
|
||||
};
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
|
||||
// compare whether a value has changed, accounting for NaN.
|
||||
const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
|
||||
const def = (obj, key, value) => {
|
||||
Object.defineProperty(obj, key, {
|
||||
configurable: true,
|
||||
enumerable: false,
|
||||
value
|
||||
});
|
||||
};
|
||||
|
||||
const targetMap = new WeakMap();
|
||||
const effectStack = [];
|
||||
let activeEffect;
|
||||
const ITERATE_KEY = Symbol('iterate' );
|
||||
const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
|
||||
function isEffect(fn) {
|
||||
return fn && fn._isEffect === true;
|
||||
}
|
||||
function effect(fn, options = EMPTY_OBJ) {
|
||||
if (isEffect(fn)) {
|
||||
fn = fn.raw;
|
||||
}
|
||||
const effect = createReactiveEffect(fn, options);
|
||||
if (!options.lazy) {
|
||||
effect();
|
||||
}
|
||||
return effect;
|
||||
}
|
||||
function stop(effect) {
|
||||
if (effect.active) {
|
||||
cleanup(effect);
|
||||
if (effect.options.onStop) {
|
||||
effect.options.onStop();
|
||||
}
|
||||
effect.active = false;
|
||||
}
|
||||
}
|
||||
let uid = 0;
|
||||
function createReactiveEffect(fn, options) {
|
||||
const effect = function reactiveEffect() {
|
||||
if (!effect.active) {
|
||||
return fn();
|
||||
}
|
||||
if (!effectStack.includes(effect)) {
|
||||
cleanup(effect);
|
||||
try {
|
||||
enableTracking();
|
||||
effectStack.push(effect);
|
||||
activeEffect = effect;
|
||||
return fn();
|
||||
}
|
||||
finally {
|
||||
effectStack.pop();
|
||||
resetTracking();
|
||||
activeEffect = effectStack[effectStack.length - 1];
|
||||
}
|
||||
}
|
||||
};
|
||||
effect.id = uid++;
|
||||
effect.allowRecurse = !!options.allowRecurse;
|
||||
effect._isEffect = true;
|
||||
effect.active = true;
|
||||
effect.raw = fn;
|
||||
effect.deps = [];
|
||||
effect.options = options;
|
||||
return effect;
|
||||
}
|
||||
function cleanup(effect) {
|
||||
const { deps } = effect;
|
||||
if (deps.length) {
|
||||
for (let i = 0; i < deps.length; i++) {
|
||||
deps[i].delete(effect);
|
||||
}
|
||||
deps.length = 0;
|
||||
}
|
||||
}
|
||||
let shouldTrack = true;
|
||||
const trackStack = [];
|
||||
function pauseTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = false;
|
||||
}
|
||||
function enableTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = true;
|
||||
}
|
||||
function resetTracking() {
|
||||
const last = trackStack.pop();
|
||||
shouldTrack = last === undefined ? true : last;
|
||||
}
|
||||
function track(target, type, key) {
|
||||
if (!shouldTrack || activeEffect === undefined) {
|
||||
return;
|
||||
}
|
||||
let depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
targetMap.set(target, (depsMap = new Map()));
|
||||
}
|
||||
let dep = depsMap.get(key);
|
||||
if (!dep) {
|
||||
depsMap.set(key, (dep = new Set()));
|
||||
}
|
||||
if (!dep.has(activeEffect)) {
|
||||
dep.add(activeEffect);
|
||||
activeEffect.deps.push(dep);
|
||||
if (activeEffect.options.onTrack) {
|
||||
activeEffect.options.onTrack({
|
||||
effect: activeEffect,
|
||||
target,
|
||||
type,
|
||||
key
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
function trigger(target, type, key, newValue, oldValue, oldTarget) {
|
||||
const depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
// never been tracked
|
||||
return;
|
||||
}
|
||||
const effects = new Set();
|
||||
const add = (effectsToAdd) => {
|
||||
if (effectsToAdd) {
|
||||
effectsToAdd.forEach(effect => {
|
||||
if (effect !== activeEffect || effect.allowRecurse) {
|
||||
effects.add(effect);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
if (type === "clear" /* CLEAR */) {
|
||||
// collection being cleared
|
||||
// trigger all effects for target
|
||||
depsMap.forEach(add);
|
||||
}
|
||||
else if (key === 'length' && isArray(target)) {
|
||||
depsMap.forEach((dep, key) => {
|
||||
if (key === 'length' || key >= newValue) {
|
||||
add(dep);
|
||||
}
|
||||
});
|
||||
}
|
||||
else {
|
||||
// schedule runs for SET | ADD | DELETE
|
||||
if (key !== void 0) {
|
||||
add(depsMap.get(key));
|
||||
}
|
||||
// also run for iteration key on ADD | DELETE | Map.SET
|
||||
switch (type) {
|
||||
case "add" /* ADD */:
|
||||
if (!isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
else if (isIntegerKey(key)) {
|
||||
// new index added to array -> length changes
|
||||
add(depsMap.get('length'));
|
||||
}
|
||||
break;
|
||||
case "delete" /* DELETE */:
|
||||
if (!isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "set" /* SET */:
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
const run = (effect) => {
|
||||
if (effect.options.onTrigger) {
|
||||
effect.options.onTrigger({
|
||||
effect,
|
||||
target,
|
||||
key,
|
||||
type,
|
||||
newValue,
|
||||
oldValue,
|
||||
oldTarget
|
||||
});
|
||||
}
|
||||
if (effect.options.scheduler) {
|
||||
effect.options.scheduler(effect);
|
||||
}
|
||||
else {
|
||||
effect();
|
||||
}
|
||||
};
|
||||
effects.forEach(run);
|
||||
}
|
||||
|
||||
const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
|
||||
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
|
||||
.map(key => Symbol[key])
|
||||
.filter(isSymbol));
|
||||
const get = /*#__PURE__*/ createGetter();
|
||||
const shallowGet = /*#__PURE__*/ createGetter(false, true);
|
||||
const readonlyGet = /*#__PURE__*/ createGetter(true);
|
||||
const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
|
||||
const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
|
||||
function createArrayInstrumentations() {
|
||||
const instrumentations = {};
|
||||
['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
const arr = toRaw(this);
|
||||
for (let i = 0, l = this.length; i < l; i++) {
|
||||
track(arr, "get" /* GET */, i + '');
|
||||
}
|
||||
// we run the method using the original args first (which may be reactive)
|
||||
const res = arr[key](...args);
|
||||
if (res === -1 || res === false) {
|
||||
// if that didn't work, run it again using raw values.
|
||||
return arr[key](...args.map(toRaw));
|
||||
}
|
||||
else {
|
||||
return res;
|
||||
}
|
||||
};
|
||||
});
|
||||
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
pauseTracking();
|
||||
const res = toRaw(this)[key].apply(this, args);
|
||||
resetTracking();
|
||||
return res;
|
||||
};
|
||||
});
|
||||
return instrumentations;
|
||||
}
|
||||
function createGetter(isReadonly = false, shallow = false) {
|
||||
return function get(target, key, receiver) {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */ &&
|
||||
receiver ===
|
||||
(isReadonly
|
||||
? shallow
|
||||
? shallowReadonlyMap
|
||||
: readonlyMap
|
||||
: shallow
|
||||
? shallowReactiveMap
|
||||
: reactiveMap).get(target)) {
|
||||
return target;
|
||||
}
|
||||
const targetIsArray = isArray(target);
|
||||
if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
|
||||
return Reflect.get(arrayInstrumentations, key, receiver);
|
||||
}
|
||||
const res = Reflect.get(target, key, receiver);
|
||||
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
|
||||
return res;
|
||||
}
|
||||
if (!isReadonly) {
|
||||
track(target, "get" /* GET */, key);
|
||||
}
|
||||
if (shallow) {
|
||||
return res;
|
||||
}
|
||||
if (isRef(res)) {
|
||||
// ref unwrapping - does not apply for Array + integer key.
|
||||
const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
|
||||
return shouldUnwrap ? res.value : res;
|
||||
}
|
||||
if (isObject(res)) {
|
||||
// Convert returned value into a proxy as well. we do the isObject check
|
||||
// here to avoid invalid value warning. Also need to lazy access readonly
|
||||
// and reactive here to avoid circular dependency.
|
||||
return isReadonly ? readonly(res) : reactive(res);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
}
|
||||
const set = /*#__PURE__*/ createSetter();
|
||||
const shallowSet = /*#__PURE__*/ createSetter(true);
|
||||
function createSetter(shallow = false) {
|
||||
return function set(target, key, value, receiver) {
|
||||
let oldValue = target[key];
|
||||
if (!shallow) {
|
||||
value = toRaw(value);
|
||||
oldValue = toRaw(oldValue);
|
||||
if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
const hadKey = isArray(target) && isIntegerKey(key)
|
||||
? Number(key) < target.length
|
||||
: hasOwn(target, key);
|
||||
const result = Reflect.set(target, key, value, receiver);
|
||||
// don't trigger if target is something up in the prototype chain of original
|
||||
if (target === toRaw(receiver)) {
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value, oldValue);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
}
|
||||
function deleteProperty(target, key) {
|
||||
const hadKey = hasOwn(target, key);
|
||||
const oldValue = target[key];
|
||||
const result = Reflect.deleteProperty(target, key);
|
||||
if (result && hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function has(target, key) {
|
||||
const result = Reflect.has(target, key);
|
||||
if (!isSymbol(key) || !builtInSymbols.has(key)) {
|
||||
track(target, "has" /* HAS */, key);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function ownKeys(target) {
|
||||
track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const mutableHandlers = {
|
||||
get,
|
||||
set,
|
||||
deleteProperty,
|
||||
has,
|
||||
ownKeys
|
||||
};
|
||||
const readonlyHandlers = {
|
||||
get: readonlyGet,
|
||||
set(target, key) {
|
||||
{
|
||||
console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
|
||||
}
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, key) {
|
||||
{
|
||||
console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
|
||||
get: shallowGet,
|
||||
set: shallowSet
|
||||
});
|
||||
// Props handlers are special in the sense that it should not unwrap top-level
|
||||
// refs (in order to allow refs to be explicitly passed down), but should
|
||||
// retain the reactivity of the normal readonly object.
|
||||
const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
|
||||
get: shallowReadonlyGet
|
||||
});
|
||||
|
||||
const toReactive = (value) => isObject(value) ? reactive(value) : value;
|
||||
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
|
||||
const toShallow = (value) => value;
|
||||
const getProto = (v) => Reflect.getPrototypeOf(v);
|
||||
function get$1(target, key, isReadonly = false, isShallow = false) {
|
||||
// #1772: readonly(reactive(Map)) should return readonly + reactive version
|
||||
// of the value
|
||||
target = target["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
|
||||
const { has } = getProto(rawTarget);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
if (has.call(rawTarget, key)) {
|
||||
return wrap(target.get(key));
|
||||
}
|
||||
else if (has.call(rawTarget, rawKey)) {
|
||||
return wrap(target.get(rawKey));
|
||||
}
|
||||
else if (target !== rawTarget) {
|
||||
// #3602 readonly(reactive(Map))
|
||||
// ensure that the nested reactive `Map` can do tracking for itself
|
||||
target.get(key);
|
||||
}
|
||||
}
|
||||
function has$1(key, isReadonly = false) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
|
||||
return key === rawKey
|
||||
? target.has(key)
|
||||
: target.has(key) || target.has(rawKey);
|
||||
}
|
||||
function size(target, isReadonly = false) {
|
||||
target = target["__v_raw" /* RAW */];
|
||||
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return Reflect.get(target, 'size', target);
|
||||
}
|
||||
function add(value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const proto = getProto(target);
|
||||
const hadKey = proto.has.call(target, value);
|
||||
if (!hadKey) {
|
||||
target.add(value);
|
||||
trigger(target, "add" /* ADD */, value, value);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function set$1(key, value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
else {
|
||||
checkIdentityKeys(target, has, key);
|
||||
}
|
||||
const oldValue = get.call(target, key);
|
||||
target.set(key, value);
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value, oldValue);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function deleteEntry(key) {
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
else {
|
||||
checkIdentityKeys(target, has, key);
|
||||
}
|
||||
const oldValue = get ? get.call(target, key) : undefined;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.delete(key);
|
||||
if (hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function clear() {
|
||||
const target = toRaw(this);
|
||||
const hadItems = target.size !== 0;
|
||||
const oldTarget = isMap(target)
|
||||
? new Map(target)
|
||||
: new Set(target)
|
||||
;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.clear();
|
||||
if (hadItems) {
|
||||
trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function createForEach(isReadonly, isShallow) {
|
||||
return function forEach(callback, thisArg) {
|
||||
const observed = this;
|
||||
const target = observed["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return target.forEach((value, key) => {
|
||||
// important: make sure the callback is
|
||||
// 1. invoked with the reactive map as `this` and 3rd arg
|
||||
// 2. the value received should be a corresponding reactive/readonly.
|
||||
return callback.call(thisArg, wrap(value), wrap(key), observed);
|
||||
});
|
||||
};
|
||||
}
|
||||
function createIterableMethod(method, isReadonly, isShallow) {
|
||||
return function (...args) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const targetIsMap = isMap(rawTarget);
|
||||
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
|
||||
const isKeyOnly = method === 'keys' && targetIsMap;
|
||||
const innerIterator = target[method](...args);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly &&
|
||||
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
|
||||
// return a wrapped iterator which returns observed versions of the
|
||||
// values emitted from the real iterator
|
||||
return {
|
||||
// iterator protocol
|
||||
next() {
|
||||
const { value, done } = innerIterator.next();
|
||||
return done
|
||||
? { value, done }
|
||||
: {
|
||||
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
|
||||
done
|
||||
};
|
||||
},
|
||||
// iterable protocol
|
||||
[Symbol.iterator]() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
function createReadonlyMethod(type) {
|
||||
return function (...args) {
|
||||
{
|
||||
const key = args[0] ? `on key "${args[0]}" ` : ``;
|
||||
console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
|
||||
}
|
||||
return type === "delete" /* DELETE */ ? false : this;
|
||||
};
|
||||
}
|
||||
function createInstrumentations() {
|
||||
const mutableInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, false)
|
||||
};
|
||||
const shallowInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, false, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, true)
|
||||
};
|
||||
const readonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, false)
|
||||
};
|
||||
const shallowReadonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, true)
|
||||
};
|
||||
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
|
||||
iteratorMethods.forEach(method => {
|
||||
mutableInstrumentations[method] = createIterableMethod(method, false, false);
|
||||
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
|
||||
shallowInstrumentations[method] = createIterableMethod(method, false, true);
|
||||
shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
|
||||
});
|
||||
return [
|
||||
mutableInstrumentations,
|
||||
readonlyInstrumentations,
|
||||
shallowInstrumentations,
|
||||
shallowReadonlyInstrumentations
|
||||
];
|
||||
}
|
||||
const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
|
||||
function createInstrumentationGetter(isReadonly, shallow) {
|
||||
const instrumentations = shallow
|
||||
? isReadonly
|
||||
? shallowReadonlyInstrumentations
|
||||
: shallowInstrumentations
|
||||
: isReadonly
|
||||
? readonlyInstrumentations
|
||||
: mutableInstrumentations;
|
||||
return (target, key, receiver) => {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */) {
|
||||
return target;
|
||||
}
|
||||
return Reflect.get(hasOwn(instrumentations, key) && key in target
|
||||
? instrumentations
|
||||
: target, key, receiver);
|
||||
};
|
||||
}
|
||||
const mutableCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, false)
|
||||
};
|
||||
const shallowCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, true)
|
||||
};
|
||||
const readonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, false)
|
||||
};
|
||||
const shallowReadonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, true)
|
||||
};
|
||||
function checkIdentityKeys(target, has, key) {
|
||||
const rawKey = toRaw(key);
|
||||
if (rawKey !== key && has.call(target, rawKey)) {
|
||||
const type = toRawType(target);
|
||||
console.warn(`Reactive ${type} contains both the raw and reactive ` +
|
||||
`versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
|
||||
`which can lead to inconsistencies. ` +
|
||||
`Avoid differentiating between the raw and reactive versions ` +
|
||||
`of an object and only use the reactive version if possible.`);
|
||||
}
|
||||
}
|
||||
|
||||
const reactiveMap = new WeakMap();
|
||||
const shallowReactiveMap = new WeakMap();
|
||||
const readonlyMap = new WeakMap();
|
||||
const shallowReadonlyMap = new WeakMap();
|
||||
function targetTypeMap(rawType) {
|
||||
switch (rawType) {
|
||||
case 'Object':
|
||||
case 'Array':
|
||||
return 1 /* COMMON */;
|
||||
case 'Map':
|
||||
case 'Set':
|
||||
case 'WeakMap':
|
||||
case 'WeakSet':
|
||||
return 2 /* COLLECTION */;
|
||||
default:
|
||||
return 0 /* INVALID */;
|
||||
}
|
||||
}
|
||||
function getTargetType(value) {
|
||||
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
|
||||
? 0 /* INVALID */
|
||||
: targetTypeMap(toRawType(value));
|
||||
}
|
||||
function reactive(target) {
|
||||
// if trying to observe a readonly proxy, return the readonly version.
|
||||
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
|
||||
return target;
|
||||
}
|
||||
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
|
||||
}
|
||||
/**
|
||||
* Return a shallowly-reactive copy of the original object, where only the root
|
||||
* level properties are reactive. It also does not auto-unwrap refs (even at the
|
||||
* root level).
|
||||
*/
|
||||
function shallowReactive(target) {
|
||||
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
|
||||
}
|
||||
/**
|
||||
* Creates a readonly copy of the original object. Note the returned copy is not
|
||||
* made reactive, but `readonly` can be called on an already reactive object.
|
||||
*/
|
||||
function readonly(target) {
|
||||
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
|
||||
}
|
||||
/**
|
||||
* Returns a reactive-copy of the original object, where only the root level
|
||||
* properties are readonly, and does NOT unwrap refs nor recursively convert
|
||||
* returned properties.
|
||||
* This is used for creating the props proxy object for stateful components.
|
||||
*/
|
||||
function shallowReadonly(target) {
|
||||
return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
|
||||
}
|
||||
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
|
||||
if (!isObject(target)) {
|
||||
{
|
||||
console.warn(`value cannot be made reactive: ${String(target)}`);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
// target is already a Proxy, return it.
|
||||
// exception: calling readonly() on a reactive object
|
||||
if (target["__v_raw" /* RAW */] &&
|
||||
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
|
||||
return target;
|
||||
}
|
||||
// target already has corresponding Proxy
|
||||
const existingProxy = proxyMap.get(target);
|
||||
if (existingProxy) {
|
||||
return existingProxy;
|
||||
}
|
||||
// only a whitelist of value types can be observed.
|
||||
const targetType = getTargetType(target);
|
||||
if (targetType === 0 /* INVALID */) {
|
||||
return target;
|
||||
}
|
||||
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
|
||||
proxyMap.set(target, proxy);
|
||||
return proxy;
|
||||
}
|
||||
function isReactive(value) {
|
||||
if (isReadonly(value)) {
|
||||
return isReactive(value["__v_raw" /* RAW */]);
|
||||
}
|
||||
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
|
||||
}
|
||||
function isReadonly(value) {
|
||||
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
|
||||
}
|
||||
function isProxy(value) {
|
||||
return isReactive(value) || isReadonly(value);
|
||||
}
|
||||
function toRaw(observed) {
|
||||
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
|
||||
}
|
||||
function markRaw(value) {
|
||||
def(value, "__v_skip" /* SKIP */, true);
|
||||
return value;
|
||||
}
|
||||
|
||||
const convert = (val) => isObject(val) ? reactive(val) : val;
|
||||
function isRef(r) {
|
||||
return Boolean(r && r.__v_isRef === true);
|
||||
}
|
||||
function ref(value) {
|
||||
return createRef(value);
|
||||
}
|
||||
function shallowRef(value) {
|
||||
return createRef(value, true);
|
||||
}
|
||||
class RefImpl {
|
||||
constructor(value, _shallow = false) {
|
||||
this._shallow = _shallow;
|
||||
this.__v_isRef = true;
|
||||
this._rawValue = _shallow ? value : toRaw(value);
|
||||
this._value = _shallow ? value : convert(value);
|
||||
}
|
||||
get value() {
|
||||
track(toRaw(this), "get" /* GET */, 'value');
|
||||
return this._value;
|
||||
}
|
||||
set value(newVal) {
|
||||
newVal = this._shallow ? newVal : toRaw(newVal);
|
||||
if (hasChanged(newVal, this._rawValue)) {
|
||||
this._rawValue = newVal;
|
||||
this._value = this._shallow ? newVal : convert(newVal);
|
||||
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
|
||||
}
|
||||
}
|
||||
}
|
||||
function createRef(rawValue, shallow = false) {
|
||||
if (isRef(rawValue)) {
|
||||
return rawValue;
|
||||
}
|
||||
return new RefImpl(rawValue, shallow);
|
||||
}
|
||||
function triggerRef(ref) {
|
||||
trigger(toRaw(ref), "set" /* SET */, 'value', ref.value );
|
||||
}
|
||||
function unref(ref) {
|
||||
return isRef(ref) ? ref.value : ref;
|
||||
}
|
||||
const shallowUnwrapHandlers = {
|
||||
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
|
||||
set: (target, key, value, receiver) => {
|
||||
const oldValue = target[key];
|
||||
if (isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return Reflect.set(target, key, value, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
function proxyRefs(objectWithRefs) {
|
||||
return isReactive(objectWithRefs)
|
||||
? objectWithRefs
|
||||
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
|
||||
}
|
||||
class CustomRefImpl {
|
||||
constructor(factory) {
|
||||
this.__v_isRef = true;
|
||||
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
|
||||
this._get = get;
|
||||
this._set = set;
|
||||
}
|
||||
get value() {
|
||||
return this._get();
|
||||
}
|
||||
set value(newVal) {
|
||||
this._set(newVal);
|
||||
}
|
||||
}
|
||||
function customRef(factory) {
|
||||
return new CustomRefImpl(factory);
|
||||
}
|
||||
function toRefs(object) {
|
||||
if (!isProxy(object)) {
|
||||
console.warn(`toRefs() expects a reactive object but received a plain one.`);
|
||||
}
|
||||
const ret = isArray(object) ? new Array(object.length) : {};
|
||||
for (const key in object) {
|
||||
ret[key] = toRef(object, key);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
class ObjectRefImpl {
|
||||
constructor(_object, _key) {
|
||||
this._object = _object;
|
||||
this._key = _key;
|
||||
this.__v_isRef = true;
|
||||
}
|
||||
get value() {
|
||||
return this._object[this._key];
|
||||
}
|
||||
set value(newVal) {
|
||||
this._object[this._key] = newVal;
|
||||
}
|
||||
}
|
||||
function toRef(object, key) {
|
||||
return isRef(object[key])
|
||||
? object[key]
|
||||
: new ObjectRefImpl(object, key);
|
||||
}
|
||||
|
||||
class ComputedRefImpl {
|
||||
constructor(getter, _setter, isReadonly) {
|
||||
this._setter = _setter;
|
||||
this._dirty = true;
|
||||
this.__v_isRef = true;
|
||||
this.effect = effect(getter, {
|
||||
lazy: true,
|
||||
scheduler: () => {
|
||||
if (!this._dirty) {
|
||||
this._dirty = true;
|
||||
trigger(toRaw(this), "set" /* SET */, 'value');
|
||||
}
|
||||
}
|
||||
});
|
||||
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
|
||||
}
|
||||
get value() {
|
||||
// the computed ref may get wrapped by other proxies e.g. readonly() #3376
|
||||
const self = toRaw(this);
|
||||
if (self._dirty) {
|
||||
self._value = this.effect();
|
||||
self._dirty = false;
|
||||
}
|
||||
track(self, "get" /* GET */, 'value');
|
||||
return self._value;
|
||||
}
|
||||
set value(newValue) {
|
||||
this._setter(newValue);
|
||||
}
|
||||
}
|
||||
function computed(getterOrOptions) {
|
||||
let getter;
|
||||
let setter;
|
||||
if (isFunction(getterOrOptions)) {
|
||||
getter = getterOrOptions;
|
||||
setter = () => {
|
||||
console.warn('Write operation failed: computed value is readonly');
|
||||
}
|
||||
;
|
||||
}
|
||||
else {
|
||||
getter = getterOrOptions.get;
|
||||
setter = getterOrOptions.set;
|
||||
}
|
||||
return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
|
||||
}
|
||||
|
||||
export { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -1,904 +0,0 @@
|
|||
import { EMPTY_OBJ, isArray, isMap, isIntegerKey, isSymbol, extend, hasOwn, isObject, hasChanged, makeMap, capitalize, toRawType, def, isFunction, NOOP } from '@vue/shared';
|
||||
|
||||
const targetMap = new WeakMap();
|
||||
const effectStack = [];
|
||||
let activeEffect;
|
||||
const ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');
|
||||
const MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');
|
||||
function isEffect(fn) {
|
||||
return fn && fn._isEffect === true;
|
||||
}
|
||||
function effect(fn, options = EMPTY_OBJ) {
|
||||
if (isEffect(fn)) {
|
||||
fn = fn.raw;
|
||||
}
|
||||
const effect = createReactiveEffect(fn, options);
|
||||
if (!options.lazy) {
|
||||
effect();
|
||||
}
|
||||
return effect;
|
||||
}
|
||||
function stop(effect) {
|
||||
if (effect.active) {
|
||||
cleanup(effect);
|
||||
if (effect.options.onStop) {
|
||||
effect.options.onStop();
|
||||
}
|
||||
effect.active = false;
|
||||
}
|
||||
}
|
||||
let uid = 0;
|
||||
function createReactiveEffect(fn, options) {
|
||||
const effect = function reactiveEffect() {
|
||||
if (!effect.active) {
|
||||
return fn();
|
||||
}
|
||||
if (!effectStack.includes(effect)) {
|
||||
cleanup(effect);
|
||||
try {
|
||||
enableTracking();
|
||||
effectStack.push(effect);
|
||||
activeEffect = effect;
|
||||
return fn();
|
||||
}
|
||||
finally {
|
||||
effectStack.pop();
|
||||
resetTracking();
|
||||
activeEffect = effectStack[effectStack.length - 1];
|
||||
}
|
||||
}
|
||||
};
|
||||
effect.id = uid++;
|
||||
effect.allowRecurse = !!options.allowRecurse;
|
||||
effect._isEffect = true;
|
||||
effect.active = true;
|
||||
effect.raw = fn;
|
||||
effect.deps = [];
|
||||
effect.options = options;
|
||||
return effect;
|
||||
}
|
||||
function cleanup(effect) {
|
||||
const { deps } = effect;
|
||||
if (deps.length) {
|
||||
for (let i = 0; i < deps.length; i++) {
|
||||
deps[i].delete(effect);
|
||||
}
|
||||
deps.length = 0;
|
||||
}
|
||||
}
|
||||
let shouldTrack = true;
|
||||
const trackStack = [];
|
||||
function pauseTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = false;
|
||||
}
|
||||
function enableTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = true;
|
||||
}
|
||||
function resetTracking() {
|
||||
const last = trackStack.pop();
|
||||
shouldTrack = last === undefined ? true : last;
|
||||
}
|
||||
function track(target, type, key) {
|
||||
if (!shouldTrack || activeEffect === undefined) {
|
||||
return;
|
||||
}
|
||||
let depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
targetMap.set(target, (depsMap = new Map()));
|
||||
}
|
||||
let dep = depsMap.get(key);
|
||||
if (!dep) {
|
||||
depsMap.set(key, (dep = new Set()));
|
||||
}
|
||||
if (!dep.has(activeEffect)) {
|
||||
dep.add(activeEffect);
|
||||
activeEffect.deps.push(dep);
|
||||
if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {
|
||||
activeEffect.options.onTrack({
|
||||
effect: activeEffect,
|
||||
target,
|
||||
type,
|
||||
key
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
function trigger(target, type, key, newValue, oldValue, oldTarget) {
|
||||
const depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
// never been tracked
|
||||
return;
|
||||
}
|
||||
const effects = new Set();
|
||||
const add = (effectsToAdd) => {
|
||||
if (effectsToAdd) {
|
||||
effectsToAdd.forEach(effect => {
|
||||
if (effect !== activeEffect || effect.allowRecurse) {
|
||||
effects.add(effect);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
if (type === "clear" /* CLEAR */) {
|
||||
// collection being cleared
|
||||
// trigger all effects for target
|
||||
depsMap.forEach(add);
|
||||
}
|
||||
else if (key === 'length' && isArray(target)) {
|
||||
depsMap.forEach((dep, key) => {
|
||||
if (key === 'length' || key >= newValue) {
|
||||
add(dep);
|
||||
}
|
||||
});
|
||||
}
|
||||
else {
|
||||
// schedule runs for SET | ADD | DELETE
|
||||
if (key !== void 0) {
|
||||
add(depsMap.get(key));
|
||||
}
|
||||
// also run for iteration key on ADD | DELETE | Map.SET
|
||||
switch (type) {
|
||||
case "add" /* ADD */:
|
||||
if (!isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
else if (isIntegerKey(key)) {
|
||||
// new index added to array -> length changes
|
||||
add(depsMap.get('length'));
|
||||
}
|
||||
break;
|
||||
case "delete" /* DELETE */:
|
||||
if (!isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "set" /* SET */:
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
const run = (effect) => {
|
||||
if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {
|
||||
effect.options.onTrigger({
|
||||
effect,
|
||||
target,
|
||||
key,
|
||||
type,
|
||||
newValue,
|
||||
oldValue,
|
||||
oldTarget
|
||||
});
|
||||
}
|
||||
if (effect.options.scheduler) {
|
||||
effect.options.scheduler(effect);
|
||||
}
|
||||
else {
|
||||
effect();
|
||||
}
|
||||
};
|
||||
effects.forEach(run);
|
||||
}
|
||||
|
||||
const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
|
||||
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
|
||||
.map(key => Symbol[key])
|
||||
.filter(isSymbol));
|
||||
const get = /*#__PURE__*/ createGetter();
|
||||
const shallowGet = /*#__PURE__*/ createGetter(false, true);
|
||||
const readonlyGet = /*#__PURE__*/ createGetter(true);
|
||||
const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
|
||||
const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
|
||||
function createArrayInstrumentations() {
|
||||
const instrumentations = {};
|
||||
['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
const arr = toRaw(this);
|
||||
for (let i = 0, l = this.length; i < l; i++) {
|
||||
track(arr, "get" /* GET */, i + '');
|
||||
}
|
||||
// we run the method using the original args first (which may be reactive)
|
||||
const res = arr[key](...args);
|
||||
if (res === -1 || res === false) {
|
||||
// if that didn't work, run it again using raw values.
|
||||
return arr[key](...args.map(toRaw));
|
||||
}
|
||||
else {
|
||||
return res;
|
||||
}
|
||||
};
|
||||
});
|
||||
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
pauseTracking();
|
||||
const res = toRaw(this)[key].apply(this, args);
|
||||
resetTracking();
|
||||
return res;
|
||||
};
|
||||
});
|
||||
return instrumentations;
|
||||
}
|
||||
function createGetter(isReadonly = false, shallow = false) {
|
||||
return function get(target, key, receiver) {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */ &&
|
||||
receiver ===
|
||||
(isReadonly
|
||||
? shallow
|
||||
? shallowReadonlyMap
|
||||
: readonlyMap
|
||||
: shallow
|
||||
? shallowReactiveMap
|
||||
: reactiveMap).get(target)) {
|
||||
return target;
|
||||
}
|
||||
const targetIsArray = isArray(target);
|
||||
if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
|
||||
return Reflect.get(arrayInstrumentations, key, receiver);
|
||||
}
|
||||
const res = Reflect.get(target, key, receiver);
|
||||
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
|
||||
return res;
|
||||
}
|
||||
if (!isReadonly) {
|
||||
track(target, "get" /* GET */, key);
|
||||
}
|
||||
if (shallow) {
|
||||
return res;
|
||||
}
|
||||
if (isRef(res)) {
|
||||
// ref unwrapping - does not apply for Array + integer key.
|
||||
const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
|
||||
return shouldUnwrap ? res.value : res;
|
||||
}
|
||||
if (isObject(res)) {
|
||||
// Convert returned value into a proxy as well. we do the isObject check
|
||||
// here to avoid invalid value warning. Also need to lazy access readonly
|
||||
// and reactive here to avoid circular dependency.
|
||||
return isReadonly ? readonly(res) : reactive(res);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
}
|
||||
const set = /*#__PURE__*/ createSetter();
|
||||
const shallowSet = /*#__PURE__*/ createSetter(true);
|
||||
function createSetter(shallow = false) {
|
||||
return function set(target, key, value, receiver) {
|
||||
let oldValue = target[key];
|
||||
if (!shallow) {
|
||||
value = toRaw(value);
|
||||
oldValue = toRaw(oldValue);
|
||||
if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
const hadKey = isArray(target) && isIntegerKey(key)
|
||||
? Number(key) < target.length
|
||||
: hasOwn(target, key);
|
||||
const result = Reflect.set(target, key, value, receiver);
|
||||
// don't trigger if target is something up in the prototype chain of original
|
||||
if (target === toRaw(receiver)) {
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value, oldValue);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
}
|
||||
function deleteProperty(target, key) {
|
||||
const hadKey = hasOwn(target, key);
|
||||
const oldValue = target[key];
|
||||
const result = Reflect.deleteProperty(target, key);
|
||||
if (result && hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function has(target, key) {
|
||||
const result = Reflect.has(target, key);
|
||||
if (!isSymbol(key) || !builtInSymbols.has(key)) {
|
||||
track(target, "has" /* HAS */, key);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function ownKeys(target) {
|
||||
track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const mutableHandlers = {
|
||||
get,
|
||||
set,
|
||||
deleteProperty,
|
||||
has,
|
||||
ownKeys
|
||||
};
|
||||
const readonlyHandlers = {
|
||||
get: readonlyGet,
|
||||
set(target, key) {
|
||||
if ((process.env.NODE_ENV !== 'production')) {
|
||||
console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
|
||||
}
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, key) {
|
||||
if ((process.env.NODE_ENV !== 'production')) {
|
||||
console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
|
||||
get: shallowGet,
|
||||
set: shallowSet
|
||||
});
|
||||
// Props handlers are special in the sense that it should not unwrap top-level
|
||||
// refs (in order to allow refs to be explicitly passed down), but should
|
||||
// retain the reactivity of the normal readonly object.
|
||||
const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
|
||||
get: shallowReadonlyGet
|
||||
});
|
||||
|
||||
const toReactive = (value) => isObject(value) ? reactive(value) : value;
|
||||
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
|
||||
const toShallow = (value) => value;
|
||||
const getProto = (v) => Reflect.getPrototypeOf(v);
|
||||
function get$1(target, key, isReadonly = false, isShallow = false) {
|
||||
// #1772: readonly(reactive(Map)) should return readonly + reactive version
|
||||
// of the value
|
||||
target = target["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
|
||||
const { has } = getProto(rawTarget);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
if (has.call(rawTarget, key)) {
|
||||
return wrap(target.get(key));
|
||||
}
|
||||
else if (has.call(rawTarget, rawKey)) {
|
||||
return wrap(target.get(rawKey));
|
||||
}
|
||||
else if (target !== rawTarget) {
|
||||
// #3602 readonly(reactive(Map))
|
||||
// ensure that the nested reactive `Map` can do tracking for itself
|
||||
target.get(key);
|
||||
}
|
||||
}
|
||||
function has$1(key, isReadonly = false) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
|
||||
return key === rawKey
|
||||
? target.has(key)
|
||||
: target.has(key) || target.has(rawKey);
|
||||
}
|
||||
function size(target, isReadonly = false) {
|
||||
target = target["__v_raw" /* RAW */];
|
||||
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return Reflect.get(target, 'size', target);
|
||||
}
|
||||
function add(value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const proto = getProto(target);
|
||||
const hadKey = proto.has.call(target, value);
|
||||
if (!hadKey) {
|
||||
target.add(value);
|
||||
trigger(target, "add" /* ADD */, value, value);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function set$1(key, value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
else if ((process.env.NODE_ENV !== 'production')) {
|
||||
checkIdentityKeys(target, has, key);
|
||||
}
|
||||
const oldValue = get.call(target, key);
|
||||
target.set(key, value);
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value, oldValue);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function deleteEntry(key) {
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
else if ((process.env.NODE_ENV !== 'production')) {
|
||||
checkIdentityKeys(target, has, key);
|
||||
}
|
||||
const oldValue = get ? get.call(target, key) : undefined;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.delete(key);
|
||||
if (hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function clear() {
|
||||
const target = toRaw(this);
|
||||
const hadItems = target.size !== 0;
|
||||
const oldTarget = (process.env.NODE_ENV !== 'production')
|
||||
? isMap(target)
|
||||
? new Map(target)
|
||||
: new Set(target)
|
||||
: undefined;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.clear();
|
||||
if (hadItems) {
|
||||
trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function createForEach(isReadonly, isShallow) {
|
||||
return function forEach(callback, thisArg) {
|
||||
const observed = this;
|
||||
const target = observed["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return target.forEach((value, key) => {
|
||||
// important: make sure the callback is
|
||||
// 1. invoked with the reactive map as `this` and 3rd arg
|
||||
// 2. the value received should be a corresponding reactive/readonly.
|
||||
return callback.call(thisArg, wrap(value), wrap(key), observed);
|
||||
});
|
||||
};
|
||||
}
|
||||
function createIterableMethod(method, isReadonly, isShallow) {
|
||||
return function (...args) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const targetIsMap = isMap(rawTarget);
|
||||
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
|
||||
const isKeyOnly = method === 'keys' && targetIsMap;
|
||||
const innerIterator = target[method](...args);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly &&
|
||||
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
|
||||
// return a wrapped iterator which returns observed versions of the
|
||||
// values emitted from the real iterator
|
||||
return {
|
||||
// iterator protocol
|
||||
next() {
|
||||
const { value, done } = innerIterator.next();
|
||||
return done
|
||||
? { value, done }
|
||||
: {
|
||||
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
|
||||
done
|
||||
};
|
||||
},
|
||||
// iterable protocol
|
||||
[Symbol.iterator]() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
function createReadonlyMethod(type) {
|
||||
return function (...args) {
|
||||
if ((process.env.NODE_ENV !== 'production')) {
|
||||
const key = args[0] ? `on key "${args[0]}" ` : ``;
|
||||
console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
|
||||
}
|
||||
return type === "delete" /* DELETE */ ? false : this;
|
||||
};
|
||||
}
|
||||
function createInstrumentations() {
|
||||
const mutableInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, false)
|
||||
};
|
||||
const shallowInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, false, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, true)
|
||||
};
|
||||
const readonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, false)
|
||||
};
|
||||
const shallowReadonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, true)
|
||||
};
|
||||
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
|
||||
iteratorMethods.forEach(method => {
|
||||
mutableInstrumentations[method] = createIterableMethod(method, false, false);
|
||||
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
|
||||
shallowInstrumentations[method] = createIterableMethod(method, false, true);
|
||||
shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
|
||||
});
|
||||
return [
|
||||
mutableInstrumentations,
|
||||
readonlyInstrumentations,
|
||||
shallowInstrumentations,
|
||||
shallowReadonlyInstrumentations
|
||||
];
|
||||
}
|
||||
const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
|
||||
function createInstrumentationGetter(isReadonly, shallow) {
|
||||
const instrumentations = shallow
|
||||
? isReadonly
|
||||
? shallowReadonlyInstrumentations
|
||||
: shallowInstrumentations
|
||||
: isReadonly
|
||||
? readonlyInstrumentations
|
||||
: mutableInstrumentations;
|
||||
return (target, key, receiver) => {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */) {
|
||||
return target;
|
||||
}
|
||||
return Reflect.get(hasOwn(instrumentations, key) && key in target
|
||||
? instrumentations
|
||||
: target, key, receiver);
|
||||
};
|
||||
}
|
||||
const mutableCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, false)
|
||||
};
|
||||
const shallowCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, true)
|
||||
};
|
||||
const readonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, false)
|
||||
};
|
||||
const shallowReadonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, true)
|
||||
};
|
||||
function checkIdentityKeys(target, has, key) {
|
||||
const rawKey = toRaw(key);
|
||||
if (rawKey !== key && has.call(target, rawKey)) {
|
||||
const type = toRawType(target);
|
||||
console.warn(`Reactive ${type} contains both the raw and reactive ` +
|
||||
`versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
|
||||
`which can lead to inconsistencies. ` +
|
||||
`Avoid differentiating between the raw and reactive versions ` +
|
||||
`of an object and only use the reactive version if possible.`);
|
||||
}
|
||||
}
|
||||
|
||||
const reactiveMap = new WeakMap();
|
||||
const shallowReactiveMap = new WeakMap();
|
||||
const readonlyMap = new WeakMap();
|
||||
const shallowReadonlyMap = new WeakMap();
|
||||
function targetTypeMap(rawType) {
|
||||
switch (rawType) {
|
||||
case 'Object':
|
||||
case 'Array':
|
||||
return 1 /* COMMON */;
|
||||
case 'Map':
|
||||
case 'Set':
|
||||
case 'WeakMap':
|
||||
case 'WeakSet':
|
||||
return 2 /* COLLECTION */;
|
||||
default:
|
||||
return 0 /* INVALID */;
|
||||
}
|
||||
}
|
||||
function getTargetType(value) {
|
||||
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
|
||||
? 0 /* INVALID */
|
||||
: targetTypeMap(toRawType(value));
|
||||
}
|
||||
function reactive(target) {
|
||||
// if trying to observe a readonly proxy, return the readonly version.
|
||||
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
|
||||
return target;
|
||||
}
|
||||
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
|
||||
}
|
||||
/**
|
||||
* Return a shallowly-reactive copy of the original object, where only the root
|
||||
* level properties are reactive. It also does not auto-unwrap refs (even at the
|
||||
* root level).
|
||||
*/
|
||||
function shallowReactive(target) {
|
||||
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
|
||||
}
|
||||
/**
|
||||
* Creates a readonly copy of the original object. Note the returned copy is not
|
||||
* made reactive, but `readonly` can be called on an already reactive object.
|
||||
*/
|
||||
function readonly(target) {
|
||||
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
|
||||
}
|
||||
/**
|
||||
* Returns a reactive-copy of the original object, where only the root level
|
||||
* properties are readonly, and does NOT unwrap refs nor recursively convert
|
||||
* returned properties.
|
||||
* This is used for creating the props proxy object for stateful components.
|
||||
*/
|
||||
function shallowReadonly(target) {
|
||||
return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
|
||||
}
|
||||
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
|
||||
if (!isObject(target)) {
|
||||
if ((process.env.NODE_ENV !== 'production')) {
|
||||
console.warn(`value cannot be made reactive: ${String(target)}`);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
// target is already a Proxy, return it.
|
||||
// exception: calling readonly() on a reactive object
|
||||
if (target["__v_raw" /* RAW */] &&
|
||||
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
|
||||
return target;
|
||||
}
|
||||
// target already has corresponding Proxy
|
||||
const existingProxy = proxyMap.get(target);
|
||||
if (existingProxy) {
|
||||
return existingProxy;
|
||||
}
|
||||
// only a whitelist of value types can be observed.
|
||||
const targetType = getTargetType(target);
|
||||
if (targetType === 0 /* INVALID */) {
|
||||
return target;
|
||||
}
|
||||
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
|
||||
proxyMap.set(target, proxy);
|
||||
return proxy;
|
||||
}
|
||||
function isReactive(value) {
|
||||
if (isReadonly(value)) {
|
||||
return isReactive(value["__v_raw" /* RAW */]);
|
||||
}
|
||||
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
|
||||
}
|
||||
function isReadonly(value) {
|
||||
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
|
||||
}
|
||||
function isProxy(value) {
|
||||
return isReactive(value) || isReadonly(value);
|
||||
}
|
||||
function toRaw(observed) {
|
||||
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
|
||||
}
|
||||
function markRaw(value) {
|
||||
def(value, "__v_skip" /* SKIP */, true);
|
||||
return value;
|
||||
}
|
||||
|
||||
const convert = (val) => isObject(val) ? reactive(val) : val;
|
||||
function isRef(r) {
|
||||
return Boolean(r && r.__v_isRef === true);
|
||||
}
|
||||
function ref(value) {
|
||||
return createRef(value);
|
||||
}
|
||||
function shallowRef(value) {
|
||||
return createRef(value, true);
|
||||
}
|
||||
class RefImpl {
|
||||
constructor(value, _shallow = false) {
|
||||
this._shallow = _shallow;
|
||||
this.__v_isRef = true;
|
||||
this._rawValue = _shallow ? value : toRaw(value);
|
||||
this._value = _shallow ? value : convert(value);
|
||||
}
|
||||
get value() {
|
||||
track(toRaw(this), "get" /* GET */, 'value');
|
||||
return this._value;
|
||||
}
|
||||
set value(newVal) {
|
||||
newVal = this._shallow ? newVal : toRaw(newVal);
|
||||
if (hasChanged(newVal, this._rawValue)) {
|
||||
this._rawValue = newVal;
|
||||
this._value = this._shallow ? newVal : convert(newVal);
|
||||
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
|
||||
}
|
||||
}
|
||||
}
|
||||
function createRef(rawValue, shallow = false) {
|
||||
if (isRef(rawValue)) {
|
||||
return rawValue;
|
||||
}
|
||||
return new RefImpl(rawValue, shallow);
|
||||
}
|
||||
function triggerRef(ref) {
|
||||
trigger(toRaw(ref), "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? ref.value : void 0);
|
||||
}
|
||||
function unref(ref) {
|
||||
return isRef(ref) ? ref.value : ref;
|
||||
}
|
||||
const shallowUnwrapHandlers = {
|
||||
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
|
||||
set: (target, key, value, receiver) => {
|
||||
const oldValue = target[key];
|
||||
if (isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return Reflect.set(target, key, value, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
function proxyRefs(objectWithRefs) {
|
||||
return isReactive(objectWithRefs)
|
||||
? objectWithRefs
|
||||
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
|
||||
}
|
||||
class CustomRefImpl {
|
||||
constructor(factory) {
|
||||
this.__v_isRef = true;
|
||||
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
|
||||
this._get = get;
|
||||
this._set = set;
|
||||
}
|
||||
get value() {
|
||||
return this._get();
|
||||
}
|
||||
set value(newVal) {
|
||||
this._set(newVal);
|
||||
}
|
||||
}
|
||||
function customRef(factory) {
|
||||
return new CustomRefImpl(factory);
|
||||
}
|
||||
function toRefs(object) {
|
||||
if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) {
|
||||
console.warn(`toRefs() expects a reactive object but received a plain one.`);
|
||||
}
|
||||
const ret = isArray(object) ? new Array(object.length) : {};
|
||||
for (const key in object) {
|
||||
ret[key] = toRef(object, key);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
class ObjectRefImpl {
|
||||
constructor(_object, _key) {
|
||||
this._object = _object;
|
||||
this._key = _key;
|
||||
this.__v_isRef = true;
|
||||
}
|
||||
get value() {
|
||||
return this._object[this._key];
|
||||
}
|
||||
set value(newVal) {
|
||||
this._object[this._key] = newVal;
|
||||
}
|
||||
}
|
||||
function toRef(object, key) {
|
||||
return isRef(object[key])
|
||||
? object[key]
|
||||
: new ObjectRefImpl(object, key);
|
||||
}
|
||||
|
||||
class ComputedRefImpl {
|
||||
constructor(getter, _setter, isReadonly) {
|
||||
this._setter = _setter;
|
||||
this._dirty = true;
|
||||
this.__v_isRef = true;
|
||||
this.effect = effect(getter, {
|
||||
lazy: true,
|
||||
scheduler: () => {
|
||||
if (!this._dirty) {
|
||||
this._dirty = true;
|
||||
trigger(toRaw(this), "set" /* SET */, 'value');
|
||||
}
|
||||
}
|
||||
});
|
||||
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
|
||||
}
|
||||
get value() {
|
||||
// the computed ref may get wrapped by other proxies e.g. readonly() #3376
|
||||
const self = toRaw(this);
|
||||
if (self._dirty) {
|
||||
self._value = this.effect();
|
||||
self._dirty = false;
|
||||
}
|
||||
track(self, "get" /* GET */, 'value');
|
||||
return self._value;
|
||||
}
|
||||
set value(newValue) {
|
||||
this._setter(newValue);
|
||||
}
|
||||
}
|
||||
function computed(getterOrOptions) {
|
||||
let getter;
|
||||
let setter;
|
||||
if (isFunction(getterOrOptions)) {
|
||||
getter = getterOrOptions;
|
||||
setter = (process.env.NODE_ENV !== 'production')
|
||||
? () => {
|
||||
console.warn('Write operation failed: computed value is readonly');
|
||||
}
|
||||
: NOOP;
|
||||
}
|
||||
else {
|
||||
getter = getterOrOptions.get;
|
||||
setter = getterOrOptions.set;
|
||||
}
|
||||
return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
|
||||
}
|
||||
|
||||
export { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };
|
||||
|
|
@ -1,994 +0,0 @@
|
|||
var VueReactivity = (function (exports) {
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* Make a map and return a function for checking if a key
|
||||
* is in that map.
|
||||
* IMPORTANT: all calls of this function must be prefixed with
|
||||
* \/\*#\_\_PURE\_\_\*\/
|
||||
* So that rollup can tree-shake them if necessary.
|
||||
*/
|
||||
function makeMap(str, expectsLowerCase) {
|
||||
const map = Object.create(null);
|
||||
const list = str.split(',');
|
||||
for (let i = 0; i < list.length; i++) {
|
||||
map[list[i]] = true;
|
||||
}
|
||||
return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
|
||||
}
|
||||
|
||||
const EMPTY_OBJ = Object.freeze({})
|
||||
;
|
||||
Object.freeze([]) ;
|
||||
const extend = Object.assign;
|
||||
const hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
const hasOwn = (val, key) => hasOwnProperty.call(val, key);
|
||||
const isArray = Array.isArray;
|
||||
const isMap = (val) => toTypeString(val) === '[object Map]';
|
||||
const isFunction = (val) => typeof val === 'function';
|
||||
const isString = (val) => typeof val === 'string';
|
||||
const isSymbol = (val) => typeof val === 'symbol';
|
||||
const isObject = (val) => val !== null && typeof val === 'object';
|
||||
const objectToString = Object.prototype.toString;
|
||||
const toTypeString = (value) => objectToString.call(value);
|
||||
const toRawType = (value) => {
|
||||
// extract "RawType" from strings like "[object RawType]"
|
||||
return toTypeString(value).slice(8, -1);
|
||||
};
|
||||
const isIntegerKey = (key) => isString(key) &&
|
||||
key !== 'NaN' &&
|
||||
key[0] !== '-' &&
|
||||
'' + parseInt(key, 10) === key;
|
||||
const cacheStringFunction = (fn) => {
|
||||
const cache = Object.create(null);
|
||||
return ((str) => {
|
||||
const hit = cache[str];
|
||||
return hit || (cache[str] = fn(str));
|
||||
});
|
||||
};
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
|
||||
// compare whether a value has changed, accounting for NaN.
|
||||
const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
|
||||
const def = (obj, key, value) => {
|
||||
Object.defineProperty(obj, key, {
|
||||
configurable: true,
|
||||
enumerable: false,
|
||||
value
|
||||
});
|
||||
};
|
||||
|
||||
const targetMap = new WeakMap();
|
||||
const effectStack = [];
|
||||
let activeEffect;
|
||||
const ITERATE_KEY = Symbol('iterate' );
|
||||
const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
|
||||
function isEffect(fn) {
|
||||
return fn && fn._isEffect === true;
|
||||
}
|
||||
function effect(fn, options = EMPTY_OBJ) {
|
||||
if (isEffect(fn)) {
|
||||
fn = fn.raw;
|
||||
}
|
||||
const effect = createReactiveEffect(fn, options);
|
||||
if (!options.lazy) {
|
||||
effect();
|
||||
}
|
||||
return effect;
|
||||
}
|
||||
function stop(effect) {
|
||||
if (effect.active) {
|
||||
cleanup(effect);
|
||||
if (effect.options.onStop) {
|
||||
effect.options.onStop();
|
||||
}
|
||||
effect.active = false;
|
||||
}
|
||||
}
|
||||
let uid = 0;
|
||||
function createReactiveEffect(fn, options) {
|
||||
const effect = function reactiveEffect() {
|
||||
if (!effect.active) {
|
||||
return fn();
|
||||
}
|
||||
if (!effectStack.includes(effect)) {
|
||||
cleanup(effect);
|
||||
try {
|
||||
enableTracking();
|
||||
effectStack.push(effect);
|
||||
activeEffect = effect;
|
||||
return fn();
|
||||
}
|
||||
finally {
|
||||
effectStack.pop();
|
||||
resetTracking();
|
||||
activeEffect = effectStack[effectStack.length - 1];
|
||||
}
|
||||
}
|
||||
};
|
||||
effect.id = uid++;
|
||||
effect.allowRecurse = !!options.allowRecurse;
|
||||
effect._isEffect = true;
|
||||
effect.active = true;
|
||||
effect.raw = fn;
|
||||
effect.deps = [];
|
||||
effect.options = options;
|
||||
return effect;
|
||||
}
|
||||
function cleanup(effect) {
|
||||
const { deps } = effect;
|
||||
if (deps.length) {
|
||||
for (let i = 0; i < deps.length; i++) {
|
||||
deps[i].delete(effect);
|
||||
}
|
||||
deps.length = 0;
|
||||
}
|
||||
}
|
||||
let shouldTrack = true;
|
||||
const trackStack = [];
|
||||
function pauseTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = false;
|
||||
}
|
||||
function enableTracking() {
|
||||
trackStack.push(shouldTrack);
|
||||
shouldTrack = true;
|
||||
}
|
||||
function resetTracking() {
|
||||
const last = trackStack.pop();
|
||||
shouldTrack = last === undefined ? true : last;
|
||||
}
|
||||
function track(target, type, key) {
|
||||
if (!shouldTrack || activeEffect === undefined) {
|
||||
return;
|
||||
}
|
||||
let depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
targetMap.set(target, (depsMap = new Map()));
|
||||
}
|
||||
let dep = depsMap.get(key);
|
||||
if (!dep) {
|
||||
depsMap.set(key, (dep = new Set()));
|
||||
}
|
||||
if (!dep.has(activeEffect)) {
|
||||
dep.add(activeEffect);
|
||||
activeEffect.deps.push(dep);
|
||||
if (activeEffect.options.onTrack) {
|
||||
activeEffect.options.onTrack({
|
||||
effect: activeEffect,
|
||||
target,
|
||||
type,
|
||||
key
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
function trigger(target, type, key, newValue, oldValue, oldTarget) {
|
||||
const depsMap = targetMap.get(target);
|
||||
if (!depsMap) {
|
||||
// never been tracked
|
||||
return;
|
||||
}
|
||||
const effects = new Set();
|
||||
const add = (effectsToAdd) => {
|
||||
if (effectsToAdd) {
|
||||
effectsToAdd.forEach(effect => {
|
||||
if (effect !== activeEffect || effect.allowRecurse) {
|
||||
effects.add(effect);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
if (type === "clear" /* CLEAR */) {
|
||||
// collection being cleared
|
||||
// trigger all effects for target
|
||||
depsMap.forEach(add);
|
||||
}
|
||||
else if (key === 'length' && isArray(target)) {
|
||||
depsMap.forEach((dep, key) => {
|
||||
if (key === 'length' || key >= newValue) {
|
||||
add(dep);
|
||||
}
|
||||
});
|
||||
}
|
||||
else {
|
||||
// schedule runs for SET | ADD | DELETE
|
||||
if (key !== void 0) {
|
||||
add(depsMap.get(key));
|
||||
}
|
||||
// also run for iteration key on ADD | DELETE | Map.SET
|
||||
switch (type) {
|
||||
case "add" /* ADD */:
|
||||
if (!isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
else if (isIntegerKey(key)) {
|
||||
// new index added to array -> length changes
|
||||
add(depsMap.get('length'));
|
||||
}
|
||||
break;
|
||||
case "delete" /* DELETE */:
|
||||
if (!isArray(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "set" /* SET */:
|
||||
if (isMap(target)) {
|
||||
add(depsMap.get(ITERATE_KEY));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
const run = (effect) => {
|
||||
if (effect.options.onTrigger) {
|
||||
effect.options.onTrigger({
|
||||
effect,
|
||||
target,
|
||||
key,
|
||||
type,
|
||||
newValue,
|
||||
oldValue,
|
||||
oldTarget
|
||||
});
|
||||
}
|
||||
if (effect.options.scheduler) {
|
||||
effect.options.scheduler(effect);
|
||||
}
|
||||
else {
|
||||
effect();
|
||||
}
|
||||
};
|
||||
effects.forEach(run);
|
||||
}
|
||||
|
||||
const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
|
||||
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
|
||||
.map(key => Symbol[key])
|
||||
.filter(isSymbol));
|
||||
const get = /*#__PURE__*/ createGetter();
|
||||
const shallowGet = /*#__PURE__*/ createGetter(false, true);
|
||||
const readonlyGet = /*#__PURE__*/ createGetter(true);
|
||||
const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
|
||||
const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
|
||||
function createArrayInstrumentations() {
|
||||
const instrumentations = {};
|
||||
['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
const arr = toRaw(this);
|
||||
for (let i = 0, l = this.length; i < l; i++) {
|
||||
track(arr, "get" /* GET */, i + '');
|
||||
}
|
||||
// we run the method using the original args first (which may be reactive)
|
||||
const res = arr[key](...args);
|
||||
if (res === -1 || res === false) {
|
||||
// if that didn't work, run it again using raw values.
|
||||
return arr[key](...args.map(toRaw));
|
||||
}
|
||||
else {
|
||||
return res;
|
||||
}
|
||||
};
|
||||
});
|
||||
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
|
||||
instrumentations[key] = function (...args) {
|
||||
pauseTracking();
|
||||
const res = toRaw(this)[key].apply(this, args);
|
||||
resetTracking();
|
||||
return res;
|
||||
};
|
||||
});
|
||||
return instrumentations;
|
||||
}
|
||||
function createGetter(isReadonly = false, shallow = false) {
|
||||
return function get(target, key, receiver) {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */ &&
|
||||
receiver ===
|
||||
(isReadonly
|
||||
? shallow
|
||||
? shallowReadonlyMap
|
||||
: readonlyMap
|
||||
: shallow
|
||||
? shallowReactiveMap
|
||||
: reactiveMap).get(target)) {
|
||||
return target;
|
||||
}
|
||||
const targetIsArray = isArray(target);
|
||||
if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
|
||||
return Reflect.get(arrayInstrumentations, key, receiver);
|
||||
}
|
||||
const res = Reflect.get(target, key, receiver);
|
||||
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
|
||||
return res;
|
||||
}
|
||||
if (!isReadonly) {
|
||||
track(target, "get" /* GET */, key);
|
||||
}
|
||||
if (shallow) {
|
||||
return res;
|
||||
}
|
||||
if (isRef(res)) {
|
||||
// ref unwrapping - does not apply for Array + integer key.
|
||||
const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
|
||||
return shouldUnwrap ? res.value : res;
|
||||
}
|
||||
if (isObject(res)) {
|
||||
// Convert returned value into a proxy as well. we do the isObject check
|
||||
// here to avoid invalid value warning. Also need to lazy access readonly
|
||||
// and reactive here to avoid circular dependency.
|
||||
return isReadonly ? readonly(res) : reactive(res);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
}
|
||||
const set = /*#__PURE__*/ createSetter();
|
||||
const shallowSet = /*#__PURE__*/ createSetter(true);
|
||||
function createSetter(shallow = false) {
|
||||
return function set(target, key, value, receiver) {
|
||||
let oldValue = target[key];
|
||||
if (!shallow) {
|
||||
value = toRaw(value);
|
||||
oldValue = toRaw(oldValue);
|
||||
if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
const hadKey = isArray(target) && isIntegerKey(key)
|
||||
? Number(key) < target.length
|
||||
: hasOwn(target, key);
|
||||
const result = Reflect.set(target, key, value, receiver);
|
||||
// don't trigger if target is something up in the prototype chain of original
|
||||
if (target === toRaw(receiver)) {
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value, oldValue);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
}
|
||||
function deleteProperty(target, key) {
|
||||
const hadKey = hasOwn(target, key);
|
||||
const oldValue = target[key];
|
||||
const result = Reflect.deleteProperty(target, key);
|
||||
if (result && hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function has(target, key) {
|
||||
const result = Reflect.has(target, key);
|
||||
if (!isSymbol(key) || !builtInSymbols.has(key)) {
|
||||
track(target, "has" /* HAS */, key);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function ownKeys(target) {
|
||||
track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
|
||||
return Reflect.ownKeys(target);
|
||||
}
|
||||
const mutableHandlers = {
|
||||
get,
|
||||
set,
|
||||
deleteProperty,
|
||||
has,
|
||||
ownKeys
|
||||
};
|
||||
const readonlyHandlers = {
|
||||
get: readonlyGet,
|
||||
set(target, key) {
|
||||
{
|
||||
console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
|
||||
}
|
||||
return true;
|
||||
},
|
||||
deleteProperty(target, key) {
|
||||
{
|
||||
console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
|
||||
get: shallowGet,
|
||||
set: shallowSet
|
||||
});
|
||||
// Props handlers are special in the sense that it should not unwrap top-level
|
||||
// refs (in order to allow refs to be explicitly passed down), but should
|
||||
// retain the reactivity of the normal readonly object.
|
||||
const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
|
||||
get: shallowReadonlyGet
|
||||
});
|
||||
|
||||
const toReactive = (value) => isObject(value) ? reactive(value) : value;
|
||||
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
|
||||
const toShallow = (value) => value;
|
||||
const getProto = (v) => Reflect.getPrototypeOf(v);
|
||||
function get$1(target, key, isReadonly = false, isShallow = false) {
|
||||
// #1772: readonly(reactive(Map)) should return readonly + reactive version
|
||||
// of the value
|
||||
target = target["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
|
||||
const { has } = getProto(rawTarget);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
if (has.call(rawTarget, key)) {
|
||||
return wrap(target.get(key));
|
||||
}
|
||||
else if (has.call(rawTarget, rawKey)) {
|
||||
return wrap(target.get(rawKey));
|
||||
}
|
||||
else if (target !== rawTarget) {
|
||||
// #3602 readonly(reactive(Map))
|
||||
// ensure that the nested reactive `Map` can do tracking for itself
|
||||
target.get(key);
|
||||
}
|
||||
}
|
||||
function has$1(key, isReadonly = false) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const rawKey = toRaw(key);
|
||||
if (key !== rawKey) {
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, key);
|
||||
}
|
||||
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
|
||||
return key === rawKey
|
||||
? target.has(key)
|
||||
: target.has(key) || target.has(rawKey);
|
||||
}
|
||||
function size(target, isReadonly = false) {
|
||||
target = target["__v_raw" /* RAW */];
|
||||
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return Reflect.get(target, 'size', target);
|
||||
}
|
||||
function add(value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const proto = getProto(target);
|
||||
const hadKey = proto.has.call(target, value);
|
||||
if (!hadKey) {
|
||||
target.add(value);
|
||||
trigger(target, "add" /* ADD */, value, value);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function set$1(key, value) {
|
||||
value = toRaw(value);
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
else {
|
||||
checkIdentityKeys(target, has, key);
|
||||
}
|
||||
const oldValue = get.call(target, key);
|
||||
target.set(key, value);
|
||||
if (!hadKey) {
|
||||
trigger(target, "add" /* ADD */, key, value);
|
||||
}
|
||||
else if (hasChanged(value, oldValue)) {
|
||||
trigger(target, "set" /* SET */, key, value, oldValue);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
function deleteEntry(key) {
|
||||
const target = toRaw(this);
|
||||
const { has, get } = getProto(target);
|
||||
let hadKey = has.call(target, key);
|
||||
if (!hadKey) {
|
||||
key = toRaw(key);
|
||||
hadKey = has.call(target, key);
|
||||
}
|
||||
else {
|
||||
checkIdentityKeys(target, has, key);
|
||||
}
|
||||
const oldValue = get ? get.call(target, key) : undefined;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.delete(key);
|
||||
if (hadKey) {
|
||||
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function clear() {
|
||||
const target = toRaw(this);
|
||||
const hadItems = target.size !== 0;
|
||||
const oldTarget = isMap(target)
|
||||
? new Map(target)
|
||||
: new Set(target)
|
||||
;
|
||||
// forward the operation before queueing reactions
|
||||
const result = target.clear();
|
||||
if (hadItems) {
|
||||
trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function createForEach(isReadonly, isShallow) {
|
||||
return function forEach(callback, thisArg) {
|
||||
const observed = this;
|
||||
const target = observed["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
|
||||
return target.forEach((value, key) => {
|
||||
// important: make sure the callback is
|
||||
// 1. invoked with the reactive map as `this` and 3rd arg
|
||||
// 2. the value received should be a corresponding reactive/readonly.
|
||||
return callback.call(thisArg, wrap(value), wrap(key), observed);
|
||||
});
|
||||
};
|
||||
}
|
||||
function createIterableMethod(method, isReadonly, isShallow) {
|
||||
return function (...args) {
|
||||
const target = this["__v_raw" /* RAW */];
|
||||
const rawTarget = toRaw(target);
|
||||
const targetIsMap = isMap(rawTarget);
|
||||
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
|
||||
const isKeyOnly = method === 'keys' && targetIsMap;
|
||||
const innerIterator = target[method](...args);
|
||||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||||
!isReadonly &&
|
||||
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
|
||||
// return a wrapped iterator which returns observed versions of the
|
||||
// values emitted from the real iterator
|
||||
return {
|
||||
// iterator protocol
|
||||
next() {
|
||||
const { value, done } = innerIterator.next();
|
||||
return done
|
||||
? { value, done }
|
||||
: {
|
||||
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
|
||||
done
|
||||
};
|
||||
},
|
||||
// iterable protocol
|
||||
[Symbol.iterator]() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
function createReadonlyMethod(type) {
|
||||
return function (...args) {
|
||||
{
|
||||
const key = args[0] ? `on key "${args[0]}" ` : ``;
|
||||
console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
|
||||
}
|
||||
return type === "delete" /* DELETE */ ? false : this;
|
||||
};
|
||||
}
|
||||
function createInstrumentations() {
|
||||
const mutableInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, false)
|
||||
};
|
||||
const shallowInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, false, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this);
|
||||
},
|
||||
has: has$1,
|
||||
add,
|
||||
set: set$1,
|
||||
delete: deleteEntry,
|
||||
clear,
|
||||
forEach: createForEach(false, true)
|
||||
};
|
||||
const readonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, false)
|
||||
};
|
||||
const shallowReadonlyInstrumentations = {
|
||||
get(key) {
|
||||
return get$1(this, key, true, true);
|
||||
},
|
||||
get size() {
|
||||
return size(this, true);
|
||||
},
|
||||
has(key) {
|
||||
return has$1.call(this, key, true);
|
||||
},
|
||||
add: createReadonlyMethod("add" /* ADD */),
|
||||
set: createReadonlyMethod("set" /* SET */),
|
||||
delete: createReadonlyMethod("delete" /* DELETE */),
|
||||
clear: createReadonlyMethod("clear" /* CLEAR */),
|
||||
forEach: createForEach(true, true)
|
||||
};
|
||||
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
|
||||
iteratorMethods.forEach(method => {
|
||||
mutableInstrumentations[method] = createIterableMethod(method, false, false);
|
||||
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
|
||||
shallowInstrumentations[method] = createIterableMethod(method, false, true);
|
||||
shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
|
||||
});
|
||||
return [
|
||||
mutableInstrumentations,
|
||||
readonlyInstrumentations,
|
||||
shallowInstrumentations,
|
||||
shallowReadonlyInstrumentations
|
||||
];
|
||||
}
|
||||
const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
|
||||
function createInstrumentationGetter(isReadonly, shallow) {
|
||||
const instrumentations = shallow
|
||||
? isReadonly
|
||||
? shallowReadonlyInstrumentations
|
||||
: shallowInstrumentations
|
||||
: isReadonly
|
||||
? readonlyInstrumentations
|
||||
: mutableInstrumentations;
|
||||
return (target, key, receiver) => {
|
||||
if (key === "__v_isReactive" /* IS_REACTIVE */) {
|
||||
return !isReadonly;
|
||||
}
|
||||
else if (key === "__v_isReadonly" /* IS_READONLY */) {
|
||||
return isReadonly;
|
||||
}
|
||||
else if (key === "__v_raw" /* RAW */) {
|
||||
return target;
|
||||
}
|
||||
return Reflect.get(hasOwn(instrumentations, key) && key in target
|
||||
? instrumentations
|
||||
: target, key, receiver);
|
||||
};
|
||||
}
|
||||
const mutableCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, false)
|
||||
};
|
||||
const shallowCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(false, true)
|
||||
};
|
||||
const readonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, false)
|
||||
};
|
||||
const shallowReadonlyCollectionHandlers = {
|
||||
get: /*#__PURE__*/ createInstrumentationGetter(true, true)
|
||||
};
|
||||
function checkIdentityKeys(target, has, key) {
|
||||
const rawKey = toRaw(key);
|
||||
if (rawKey !== key && has.call(target, rawKey)) {
|
||||
const type = toRawType(target);
|
||||
console.warn(`Reactive ${type} contains both the raw and reactive ` +
|
||||
`versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
|
||||
`which can lead to inconsistencies. ` +
|
||||
`Avoid differentiating between the raw and reactive versions ` +
|
||||
`of an object and only use the reactive version if possible.`);
|
||||
}
|
||||
}
|
||||
|
||||
const reactiveMap = new WeakMap();
|
||||
const shallowReactiveMap = new WeakMap();
|
||||
const readonlyMap = new WeakMap();
|
||||
const shallowReadonlyMap = new WeakMap();
|
||||
function targetTypeMap(rawType) {
|
||||
switch (rawType) {
|
||||
case 'Object':
|
||||
case 'Array':
|
||||
return 1 /* COMMON */;
|
||||
case 'Map':
|
||||
case 'Set':
|
||||
case 'WeakMap':
|
||||
case 'WeakSet':
|
||||
return 2 /* COLLECTION */;
|
||||
default:
|
||||
return 0 /* INVALID */;
|
||||
}
|
||||
}
|
||||
function getTargetType(value) {
|
||||
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
|
||||
? 0 /* INVALID */
|
||||
: targetTypeMap(toRawType(value));
|
||||
}
|
||||
function reactive(target) {
|
||||
// if trying to observe a readonly proxy, return the readonly version.
|
||||
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
|
||||
return target;
|
||||
}
|
||||
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
|
||||
}
|
||||
/**
|
||||
* Return a shallowly-reactive copy of the original object, where only the root
|
||||
* level properties are reactive. It also does not auto-unwrap refs (even at the
|
||||
* root level).
|
||||
*/
|
||||
function shallowReactive(target) {
|
||||
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
|
||||
}
|
||||
/**
|
||||
* Creates a readonly copy of the original object. Note the returned copy is not
|
||||
* made reactive, but `readonly` can be called on an already reactive object.
|
||||
*/
|
||||
function readonly(target) {
|
||||
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
|
||||
}
|
||||
/**
|
||||
* Returns a reactive-copy of the original object, where only the root level
|
||||
* properties are readonly, and does NOT unwrap refs nor recursively convert
|
||||
* returned properties.
|
||||
* This is used for creating the props proxy object for stateful components.
|
||||
*/
|
||||
function shallowReadonly(target) {
|
||||
return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
|
||||
}
|
||||
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
|
||||
if (!isObject(target)) {
|
||||
{
|
||||
console.warn(`value cannot be made reactive: ${String(target)}`);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
// target is already a Proxy, return it.
|
||||
// exception: calling readonly() on a reactive object
|
||||
if (target["__v_raw" /* RAW */] &&
|
||||
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
|
||||
return target;
|
||||
}
|
||||
// target already has corresponding Proxy
|
||||
const existingProxy = proxyMap.get(target);
|
||||
if (existingProxy) {
|
||||
return existingProxy;
|
||||
}
|
||||
// only a whitelist of value types can be observed.
|
||||
const targetType = getTargetType(target);
|
||||
if (targetType === 0 /* INVALID */) {
|
||||
return target;
|
||||
}
|
||||
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
|
||||
proxyMap.set(target, proxy);
|
||||
return proxy;
|
||||
}
|
||||
function isReactive(value) {
|
||||
if (isReadonly(value)) {
|
||||
return isReactive(value["__v_raw" /* RAW */]);
|
||||
}
|
||||
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
|
||||
}
|
||||
function isReadonly(value) {
|
||||
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
|
||||
}
|
||||
function isProxy(value) {
|
||||
return isReactive(value) || isReadonly(value);
|
||||
}
|
||||
function toRaw(observed) {
|
||||
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
|
||||
}
|
||||
function markRaw(value) {
|
||||
def(value, "__v_skip" /* SKIP */, true);
|
||||
return value;
|
||||
}
|
||||
|
||||
const convert = (val) => isObject(val) ? reactive(val) : val;
|
||||
function isRef(r) {
|
||||
return Boolean(r && r.__v_isRef === true);
|
||||
}
|
||||
function ref(value) {
|
||||
return createRef(value);
|
||||
}
|
||||
function shallowRef(value) {
|
||||
return createRef(value, true);
|
||||
}
|
||||
class RefImpl {
|
||||
constructor(value, _shallow = false) {
|
||||
this._shallow = _shallow;
|
||||
this.__v_isRef = true;
|
||||
this._rawValue = _shallow ? value : toRaw(value);
|
||||
this._value = _shallow ? value : convert(value);
|
||||
}
|
||||
get value() {
|
||||
track(toRaw(this), "get" /* GET */, 'value');
|
||||
return this._value;
|
||||
}
|
||||
set value(newVal) {
|
||||
newVal = this._shallow ? newVal : toRaw(newVal);
|
||||
if (hasChanged(newVal, this._rawValue)) {
|
||||
this._rawValue = newVal;
|
||||
this._value = this._shallow ? newVal : convert(newVal);
|
||||
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
|
||||
}
|
||||
}
|
||||
}
|
||||
function createRef(rawValue, shallow = false) {
|
||||
if (isRef(rawValue)) {
|
||||
return rawValue;
|
||||
}
|
||||
return new RefImpl(rawValue, shallow);
|
||||
}
|
||||
function triggerRef(ref) {
|
||||
trigger(toRaw(ref), "set" /* SET */, 'value', ref.value );
|
||||
}
|
||||
function unref(ref) {
|
||||
return isRef(ref) ? ref.value : ref;
|
||||
}
|
||||
const shallowUnwrapHandlers = {
|
||||
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
|
||||
set: (target, key, value, receiver) => {
|
||||
const oldValue = target[key];
|
||||
if (isRef(oldValue) && !isRef(value)) {
|
||||
oldValue.value = value;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return Reflect.set(target, key, value, receiver);
|
||||
}
|
||||
}
|
||||
};
|
||||
function proxyRefs(objectWithRefs) {
|
||||
return isReactive(objectWithRefs)
|
||||
? objectWithRefs
|
||||
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
|
||||
}
|
||||
class CustomRefImpl {
|
||||
constructor(factory) {
|
||||
this.__v_isRef = true;
|
||||
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
|
||||
this._get = get;
|
||||
this._set = set;
|
||||
}
|
||||
get value() {
|
||||
return this._get();
|
||||
}
|
||||
set value(newVal) {
|
||||
this._set(newVal);
|
||||
}
|
||||
}
|
||||
function customRef(factory) {
|
||||
return new CustomRefImpl(factory);
|
||||
}
|
||||
function toRefs(object) {
|
||||
if (!isProxy(object)) {
|
||||
console.warn(`toRefs() expects a reactive object but received a plain one.`);
|
||||
}
|
||||
const ret = isArray(object) ? new Array(object.length) : {};
|
||||
for (const key in object) {
|
||||
ret[key] = toRef(object, key);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
class ObjectRefImpl {
|
||||
constructor(_object, _key) {
|
||||
this._object = _object;
|
||||
this._key = _key;
|
||||
this.__v_isRef = true;
|
||||
}
|
||||
get value() {
|
||||
return this._object[this._key];
|
||||
}
|
||||
set value(newVal) {
|
||||
this._object[this._key] = newVal;
|
||||
}
|
||||
}
|
||||
function toRef(object, key) {
|
||||
return isRef(object[key])
|
||||
? object[key]
|
||||
: new ObjectRefImpl(object, key);
|
||||
}
|
||||
|
||||
class ComputedRefImpl {
|
||||
constructor(getter, _setter, isReadonly) {
|
||||
this._setter = _setter;
|
||||
this._dirty = true;
|
||||
this.__v_isRef = true;
|
||||
this.effect = effect(getter, {
|
||||
lazy: true,
|
||||
scheduler: () => {
|
||||
if (!this._dirty) {
|
||||
this._dirty = true;
|
||||
trigger(toRaw(this), "set" /* SET */, 'value');
|
||||
}
|
||||
}
|
||||
});
|
||||
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
|
||||
}
|
||||
get value() {
|
||||
// the computed ref may get wrapped by other proxies e.g. readonly() #3376
|
||||
const self = toRaw(this);
|
||||
if (self._dirty) {
|
||||
self._value = this.effect();
|
||||
self._dirty = false;
|
||||
}
|
||||
track(self, "get" /* GET */, 'value');
|
||||
return self._value;
|
||||
}
|
||||
set value(newValue) {
|
||||
this._setter(newValue);
|
||||
}
|
||||
}
|
||||
function computed(getterOrOptions) {
|
||||
let getter;
|
||||
let setter;
|
||||
if (isFunction(getterOrOptions)) {
|
||||
getter = getterOrOptions;
|
||||
setter = () => {
|
||||
console.warn('Write operation failed: computed value is readonly');
|
||||
}
|
||||
;
|
||||
}
|
||||
else {
|
||||
getter = getterOrOptions.get;
|
||||
setter = getterOrOptions.set;
|
||||
}
|
||||
return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
|
||||
}
|
||||
|
||||
exports.ITERATE_KEY = ITERATE_KEY;
|
||||
exports.computed = computed;
|
||||
exports.customRef = customRef;
|
||||
exports.effect = effect;
|
||||
exports.enableTracking = enableTracking;
|
||||
exports.isProxy = isProxy;
|
||||
exports.isReactive = isReactive;
|
||||
exports.isReadonly = isReadonly;
|
||||
exports.isRef = isRef;
|
||||
exports.markRaw = markRaw;
|
||||
exports.pauseTracking = pauseTracking;
|
||||
exports.proxyRefs = proxyRefs;
|
||||
exports.reactive = reactive;
|
||||
exports.readonly = readonly;
|
||||
exports.ref = ref;
|
||||
exports.resetTracking = resetTracking;
|
||||
exports.shallowReactive = shallowReactive;
|
||||
exports.shallowReadonly = shallowReadonly;
|
||||
exports.shallowRef = shallowRef;
|
||||
exports.stop = stop;
|
||||
exports.toRaw = toRaw;
|
||||
exports.toRef = toRef;
|
||||
exports.toRefs = toRefs;
|
||||
exports.track = track;
|
||||
exports.trigger = trigger;
|
||||
exports.triggerRef = triggerRef;
|
||||
exports.unref = unref;
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
return exports;
|
||||
|
||||
}({}));
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue