@zuplo/cli 7.0.2 → 7.1.0

package/node_modules/fast-copy/README.md

@@ -15,29 +15,28 @@ A [blazing fast](#benchmarks) deep object copier
     - [`copy`](#copy)
     - [`copyStrict`](#copystrict)
     - [`createCopier`](#createcopier)
-      - [Copier methods](#copier-methods)
-      - [Copier state](#copier-state)
-        - [`cache`](#cache)
-        - [`copier`](#copier)
-        - [`Constructor` / `prototype`](#constructor--prototype)
-    - [`createStrictCopier`](#createstrictcopier)
+      - [`createCache`](#createcache)
+      - [`methods`](#methods)
+        - [Copier state](#copier-state)
+          - [`cache`](#cache)
+          - [`copier`](#copier)
+          - [`Constructor` / `prototype`](#constructor--prototype)
+      - [`strict`](#strict)
   - [Types supported](#types-supported)
   - [Aspects of default copiers](#aspects-of-default-copiers)
     - [Error references are copied directly, instead of creating a new `*Error` object](#error-references-are-copied-directly-instead-of-creating-a-new-error-object)
     - [The constructor of the original object is used, instead of using known globals](#the-constructor-of-the-original-object-is-used-instead-of-using-known-globals)
-    - [Generator objects are copied, but still reference the original generator's state](#generator-objects-are-copied-but-still-reference-the-original-generators-state)
   - [Benchmarks](#benchmarks)
-      - [Simple objects](#simple-objects)
-      - [Complex objects](#complex-objects)
-      - [Big data](#big-data)
-      - [Circular objects](#circular-objects)
-      - [Special objects](#special-objects)
-  - [Development](#development)
+    - [Simple objects](#simple-objects)
+    - [Complex objects](#complex-objects)
+    - [Big data](#big-data)
+    - [Circular objects](#circular-objects)
+    - [Special objects](#special-objects)
 
 ## Usage
 
 ```js
-import copy from 'fast-copy';
+import { copy } from 'fast-copy';
 import { deepEqual } from 'fast-equals';
 
 const object = {
@@ -61,7 +60,7 @@ console.log(deepEqual(copiedObject, object)); // true
 Deeply copy the object passed.
 
 ```js
-import copy from 'fast-copy';
+import { copy } from 'fast-copy';
 
 const copied = copy({ foo: 'bar' });
 ```
@@ -86,56 +85,72 @@ object.nonEnumerable = Object.defineProperty(object, 'bar', {
 const copied = copy(object);
 ```
 
-**NOTE**: This method is significantly slower than [`copy`](#copy), so it is recommended to only use this when you have specific use-cases that require it.
+**NOTE**: This method is significantly slower than [`copy`](#copy), so it is recommended to only use this when you have
+specific use-cases that require it.
 
 ### `createCopier`
 
-Create a custom copier based on the type-specific methods passed. This is useful if you want to squeeze out maximum performance, or perform something other than a standard deep copy.
+Create a custom copier based on the type-specific method overrides passed, as well as configuration options for how
+copies should be performed. This is useful if you want to squeeze out maximum performance, or perform something other
+than a standard deep copy.
 
 ```js
 import { createCopier } from 'fast-copy';
-
-const copyShallow = createCopier({
-  array: (array) => [...array],
-  map: (map) => new Map(map.entries()),
-  object: (object) => ({ ...object }),
-  set: (set) => new Set(set.values()),
+import { LRUCache } from 'lru-cache';
+
+const copyShallowStrict = createCopier({
+  createCache: () => new LRUCache(),
+  methods: {
+    array: (array) => [...array],
+    map: (map) => new Map(map.entries()),
+    object: (object) => ({ ...object }),
+    set: (set) => new Set(set.values()),
+  },
+  strict: true,
 });
 ```
 
-Each internal copier method has the following contract:
+#### `createCache`
 
-```js
-type InternalCopier<Value> = (value: Value, state: State) => Value;
-
-interface State {
-  Constructor: any;
-  cache: WeakMap;
-  copier: InternalCopier<any>;
-  prototype: any;
-}
-```
+Method that creates the internal [`cache`](#cache) in the [Copier state](#copier-state). Defaults to creating a new
+`WeakMap` instance.
 
-Any method overriding the defaults must maintain this contract.
+#### `methods`
 
-#### Copier methods
+Methods used for copying specific object types. A list of the methods and which object types they handle:
 
 - `array` => `Array`
-- `arrayBuffer`=> `ArrayBuffer`, `Float32Array`, `Float64Array`, `Int8Array`, `Int16Array`, `Int32Array`, `Uint8Array`, `Uint8ClampedArray`, `Uint16Array`, `Uint32Array`, `Uint64Array`
+- `arrayBuffer`=> `ArrayBuffer`, `Float32Array`, `Float64Array`, `Int8Array`, `Int16Array`, `Int32Array`, `Uint8Array`,
+  `Uint8ClampedArray`, `Uint16Array`, `Uint32Array`, `BigInt64Array`, `BigUint64Array`
 - `blob` => `Blob`
 - `dataView` => `DataView`
 - `date` => `Date`
-- `error` => `Error`, `AggregateError`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError`, `URIError`
+- `error` => `Error`, `AggregateError`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError`,
+  `URIError`
 - `map` => `Map`
 - `object` => `Object`, or any custom constructor
 - `regExp` => `RegExp`
 - `set` => `Set`
 
-#### Copier state
+Each method has the following contract:
 
-##### `cache`
+```js
+type InternalCopier<Value> = (value: Value, state: State) => Value;
 
-If you want to maintain circular reference handling, then you'll need the methods to handle cache population for future lookups:
+interface State {
+  Constructor: any;
+  cache: WeakMap;
+  copier: InternalCopier<any>;
+  prototype: any;
+}
+```
+
+##### Copier state
+
+###### `cache`
+
+If you want to maintain circular reference handling, then you'll need the methods to handle cache population for future
+lookups:
 
 ```js
 function shallowlyCloneArray<Value extends any[]>(
@@ -150,7 +165,7 @@ function shallowlyCloneArray<Value extends any[]>(
 }
 ```
 
-##### `copier`
+###### `copier`
 
 `copier` is provided for recursive calls with deeply-nested objects.
 
@@ -169,11 +184,13 @@ function deeplyCloneArray<Value extends any[]>(
 }
 ```
 
-Note above I am using `forEach` instead of a simple `map`. This is because it is highly recommended to store the clone in [`cache`](#cache) eagerly when deeply copying, so that nested circular references are handled correctly.
+Note above I am using `forEach` instead of a simple `map`. This is because it is highly recommended to store the clone
+in [`cache`](#cache) eagerly when deeply copying, so that nested circular references are handled correctly.
 
-##### `Constructor` / `prototype`
+###### `Constructor` / `prototype`
 
-Both `Constructor` and `prototype` properties are only populated with complex objects that are not standard objects or arrays. This is mainly useful for custom subclasses of these globals, or maintaining custom prototypes of objects.
+Both `Constructor` and `prototype` properties are only populated with complex objects that are not standard objects or
+arrays. This is mainly useful for custom subclasses of these globals, or maintaining custom prototypes of objects.
 
 ```js
 function deeplyCloneSubclassArray<Value extends CustomArray>(
@@ -203,36 +220,13 @@ function deeplyCloneCustomObject<Value extends CustomObject>(
 }
 ```
 
-### `createStrictCopier`
+#### `strict`
 
-Create a custom copier based on the type-specific methods passed, but defaulting to the same functions normally used for `copyStrict`. This is useful if you want to squeeze out better performance while maintaining strict requirements, or perform something other than a strict deep copy.
-
-```js
-const createStrictClone = (value, clone) =>
-  Object.getOwnPropertyNames(value).reduce(
-    (clone, property) =>
-      Object.defineProperty(
-        clone,
-        property,
-        Object.getOwnPropertyDescriptor(value, property) || {
-          configurable: true,
-          enumerable: true,
-          value: clone[property],
-          writable: true,
-        }
-      ),
-    clone
-  );
-
-const copyStrictShallow = createStrictCopier({
-  array: (array) => createStrictClone(array, []),
-  map: (map) => createStrictClone(map, new Map(map.entries())),
-  object: (object) => createStrictClone(object, {}),
-  set: (set) => createStrictClone(set, new Set(set.values())),
-});
-```
+Enforces strict copying of properties, which includes properties that are not standard for that object. An example would
+be a named key on an array.
 
-**NOTE**: This method creates a copier that is significantly slower than [`copy`](#copy), as well as likely a copier created by [`createCopier`](#createcopier), so it is recommended to only use this when you have specific use-cases that require it.
+**NOTE**: This creates a copier that is significantly slower than "loose" mode, so it is recommended to only use this
+when you have specific use-cases that require it.
 
 ## Types supported
 
@@ -263,12 +257,15 @@ The following object types are deeply cloned when they are either properties on
 - `React` components
 - Custom constructors
 
-The following object types are copied directly, as they are either primitives, cannot be cloned, or the common use-case implementation does not expect cloning:
+The following object types are copied directly, as they are either primitives, cannot be cloned, or the common use-case
+implementation does not expect cloning:
 
 - `AsyncFunction`
+- `AsyncGenerator`
 - `Boolean` primitives
 - `Error`
 - `Function`
+- `Generator`
 - `GeneratorFunction`
 - `Number` primitives
 - `Null`
@@ -279,23 +276,28 @@ The following object types are copied directly, as they are either primitives, c
 - `WeakMap`
 - `WeakSet`
 
-Circular objects are supported out of the box. By default, a cache based on `WeakSet` is used, but if `WeakSet` is not available then a fallback is used. The benchmarks quoted below are based on use of `WeakSet`.
+Circular objects are supported out of the box. By default, a cache based on `WeakSet` is used, but if `WeakSet` is not
+available then a fallback is used. The benchmarks quoted below are based on use of `WeakSet`.
 
 ## Aspects of default copiers
 
-Inherently, what is considered a valid copy is subjective because of different requirements and use-cases. For this library, some decisions were explicitly made for the default copiers of specific object types, and those decisions are detailed below. If your use-cases require different handling, you can always create your own custom copier with [`createCopier`](#createcopier) or [`createStrictCopier`](#createstrictcopier).
+Inherently, what is considered a valid copy is subjective because of different requirements and use-cases. For this
+library, some decisions were explicitly made for the default copiers of specific object types, and those decisions are
+detailed below. If your use-cases require different handling, you can always create your own custom copier with
+[`createCopier`](#createcopier).
 
 ### Error references are copied directly, instead of creating a new `*Error` object
 
-While it would be relatively trivial to copy over the message and stack to a new object of the same `Error` subclass, it is a common practice to "override" the message or stack, and copies would not retain this mutation. As such, the original reference is copied.
+While it would be relatively trivial to copy over the message and stack to a new object of the same `Error` subclass, it
+is a common practice to "override" the message or stack, and copies would not retain this mutation. As such, the
+original reference is copied.
 
 ### The constructor of the original object is used, instead of using known globals
 
-Starting in ES2015, native globals can be subclassed like any custom class. When copying, we explicitly reuse the constructor of the original object. However, the expectation is that these subclasses would have the same constructur signature as their native base class. This is a common community practice, but there is the possibility of inaccuracy if the contract differs.
-
-### Generator objects are copied, but still reference the original generator's state
-
-[Generator objects](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator) are specific types of iterators, but appear like standard objects that just have a few methods (`next`, `throw`, `return`). These methods are bound to the internal state of the generator, which cannot be copied effectively. Normally this would be treated like other "uncopiable" objects and simply pass the reference through, however the "validation" of whether it is a generator object or a standard object is not guaranteed (duck-typing) and there is a runtime cost associated with. Therefore, the simplest path of treating it like a standard object (copying methods to a new object) was taken.
+Starting in ES2015, native globals can be subclassed like any custom class. When copying, we explicitly reuse the
+constructor of the original object. However, the expectation is that these subclasses would have the same constructur
+signature as their native base class. This is a common community practice, but there is the possibility of inaccuracy if
+the contract differs.
 
 ## Benchmarks
 
@@ -303,93 +305,123 @@ Starting in ES2015, native globals can be subclassed like any custom class. When
 
 _Small number of properties, all values are primitives_
 
-|                    | Operations / second |
-| ------------------ | ------------------- |
-| **fast-copy**      | **5,880,312**       |
-| lodash.cloneDeep   | 2,706,261           |
-| clone              | 2,207,231           |
-| deepclone          | 1,274,810           |
-| fast-clone         | 1,239,952           |
-| ramda              | 1,146,152           |
-| fast-copy (strict) | 852,382             |
+```bash
+┌────────────────────┬────────────────┐
+│ Name               │ Ops / sec      │
+├────────────────────┼────────────────┤
+│ fast-copy          │ 4516637.948706 │
+├────────────────────┼────────────────┤
+│ lodash.cloneDeep   │ 2726908.524823 │
+├────────────────────┼────────────────┤
+│ clone              │ 2292947.082887 │
+├────────────────────┼────────────────┤
+│ ramda              │ 1919887.358374 │
+├────────────────────┼────────────────┤
+│ fast-clone         │ 1445623.172658 │
+├────────────────────┼────────────────┤
+│ deepclone          │ 1172068.638112 │
+├────────────────────┼────────────────┤
+│ fast-copy (strict) │ 1029920.368064 │
+└────────────────────┴────────────────┘
+Fastest was "fast-copy".
+```
 
 #### Complex objects
 
 _Large number of properties, values are a combination of primitives and complex objects_
 
-|                    | Operations / second |
-| ------------------ | ------------------- |
-| **fast-copy**      | **162,858**         |
-| ramda              | 142,104             |
-| deepclone          | 133,607             |
-| fast-clone         | 101,143             |
-| clone              | 70,872              |
-| fast-copy (strict) | 62,961              |
-| lodash.cloneDeep   | 62,060              |
+```bash
+┌────────────────────┬───────────────┐
+│ Name               │ Ops / sec     │
+├────────────────────┼───────────────┤
+│ fast-copy          │ 202418.444691 │
+├────────────────────┼───────────────┤
+│ deepclone          │ 139120.811183 │
+├────────────────────┼───────────────┤
+│ clone              │ 122191.364796 │
+├────────────────────┼───────────────┤
+│ ramda              │ 106986.690081 │
+├────────────────────┼───────────────┤
+│ fast-clone         │ 102390.033243 │
+├────────────────────┼───────────────┤
+│ fast-copy (strict) │ 72306.017635  │
+├────────────────────┼───────────────┤
+│ lodash.cloneDeep   │ 68706.681189  │
+└────────────────────┴───────────────┘
+Fastest was "fast-copy".
+```
 
 #### Big data
 
 _Very large number of properties with high amount of nesting, mainly objects and arrays_
 
-|                    | Operations / second |
-| ------------------ | ------------------- |
-| **fast-copy**      | **303**             |
-| fast-clone         | 245                 |
-| deepclone          | 151                 |
-| lodash.cloneDeep   | 150                 |
-| clone              | 93                  |
-| fast-copy (strict) | 90                  |
-| ramda              | 42                  |
+```bash
+┌────────────────────┬────────────┐
+│ Name               │ Ops / sec  │
+├────────────────────┼────────────┤
+│ fast-copy          │ 564.726583 │
+├────────────────────┼────────────┤
+│ fast-clone         │ 265.243854 │
+├────────────────────┼────────────┤
+│ lodash.cloneDeep   │ 160.972258 │
+├────────────────────┼────────────┤
+│ deepclone          │ 158.201556 │
+├────────────────────┼────────────┤
+│ fast-copy (strict) │ 135.031983 │
+├────────────────────┼────────────┤
+│ clone              │ 122.876256 │
+├────────────────────┼────────────┤
+│ ramda              │ 35.226104  │
+└────────────────────┴────────────┘
+Fastest was "fast-copy".
+```
 
 #### Circular objects
 
-_Objects that deeply reference themselves_
-
-|                    | Operations / second |
-| ------------------ | ------------------- |
-| **fast-copy**      | **2,420,466**       |
-| deepclone          | 1,386,896           |
-| ramda              | 1,024,108           |
-| lodash.cloneDeep   | 989,796             |
-| clone              | 987,721             |
-| fast-copy (strict) | 617,602             |
-| fast-clone         | 0 (not supported)   |
+_Simple object with a deeply nested reference to itself_
+
+```bash
+┌────────────────────┬────────────────┐
+│ Name               │ Ops / sec      │
+├────────────────────┼────────────────┤
+│ fast-copy          │ 2265437.452915 │
+├────────────────────┼────────────────┤
+│ deepclone          │ 1078459.808203 │
+├────────────────────┼────────────────┤
+│ lodash.cloneDeep   │ 989211.772997  │
+├────────────────────┼────────────────┤
+│ fast-copy (strict) │ 865453.141899  │
+├────────────────────┼────────────────┤
+│ clone              │ 748230.731936  │
+├────────────────────┼────────────────┤
+│ ramda              │ 564490.882674  │
+├────────────────────┼────────────────┤
+│ fast-clone         │ 0              │
+└────────────────────┴────────────────┘
+Fastest was "fast-copy".
+```
 
 #### Special objects
 
 _Custom constructors, React components, etc_
 
-|                    | Operations / second |
-| ------------------ | ------------------- |
-| **fast-copy**      | **152,792**         |
-| clone              | 74,347              |
-| fast-clone         | 66,576              |
-| lodash.cloneDeep   | 64,760              |
-| ramda              | 53,542              |
-| deepclone          | 28,823              |
-| fast-copy (strict) | 21,362              |
-
-## Development
-
-Standard practice, clone the repo and `yarn` (or `npm i`) to get the dependencies. The following npm scripts are available:
-
-- benchmark => run benchmark tests against other equality libraries
-- build => run `build:esm`, `build:cjs`, `build:umd`, and `build:min` scripts
-- build:cjs => build CJS files and types
-- build:esm => build ESM files and types
-- build:min => build minified files and types
-- build:umd => build UMD files and types
-- clean => run `rimraf` on the `dist` folder
-- dev => start webpack playground App
-- dist => run `clean` and `build` scripts
-- lint => run ESLint on all files in `src` folder (also runs on `dev` script)
-- lint:fix => run `lint` script, but with auto-fixer
-- prepublishOnly => run `lint`, `test:coverage`, and `dist` scripts
-- release => run `prepublishOnly` and release with new version
-- release:beta => run `prepublishOnly` and release with new beta version
-- release:dry => run `prepublishOnly` and simulate a new release
-- start => run `dev`
-- test => run AVA with NODE_ENV=test on all files in `test` folder
-- test:coverage => run same script as `test` with code coverage calculation via `nyc`
-- test:watch => run same script as `test` but keep persistent watcher
-- typecheck => run `tsc` on the codebase
+```bash
+┌────────────────────┬───────────────┐
+│ Name               │ Ops / sec     │
+├────────────────────┼───────────────┤
+│ fast-copy          │ 134318.379975 │
+├────────────────────┼───────────────┤
+│ lodash.cloneDeep   │ 62990.463065  │
+├────────────────────┼───────────────┤
+│ clone              │ 59386.329843  │
+├────────────────────┼───────────────┤
+│ fast-clone         │ 53886.995853  │
+├────────────────────┼───────────────┤
+│ ramda              │ 27974.450157  │
+├────────────────────┼───────────────┤
+│ deepclone          │ 23498.796755  │
+├────────────────────┼───────────────┤
+│ fast-copy (strict) │ 18955.802659  │
+└────────────────────┴───────────────┘
+Fastest was "fast-copy".
+```