fast-equals 5.3.1 → 5.3.3-beta.0

package/src/equals.ts

@@ -1,10 +1,10 @@
-import { getStrictProperties, hasOwn, sameValueZeroEqual } from './utils';
+import { getStrictProperties, hasOwn, sameValueZeroEqual } from './utils.ts';
 import type {
   Dictionary,
   PrimitiveWrapper,
   State,
   TypedArray,
-} from './internalTypes';
+} from './internalTypes.ts';
 
 const PREACT_VNODE = '__v';
 const PREACT_OWNER = '__o';
@@ -78,13 +78,14 @@ export function areMapsEqual(
     return true;
   }
 
-  const matchedIndices: Array<true | undefined> = new Array(size);
+  const matchedIndices = new Array<true | undefined>(size);
   const aIterable = a.entries();
 
   let aResult: IteratorResult<[any, any]>;
   let bResult: IteratorResult<[any, any]>;
   let index = 0;
 
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   while ((aResult = aIterable.next())) {
     if (aResult.done) {
       break;
@@ -95,6 +96,7 @@ export function areMapsEqual(
     let hasMatch = false;
     let matchIndex = 0;
 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while ((bResult = bIterable.next())) {
       if (bResult.done) {
         break;
@@ -247,12 +249,13 @@ export function areSetsEqual(
     return true;
   }
 
-  const matchedIndices: Array<true | undefined> = new Array(size);
+  const matchedIndices = new Array<true | undefined>(size);
   const aIterable = a.values();
 
   let aResult: IteratorResult<any>;
   let bResult: IteratorResult<any>;
 
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   while ((aResult = aIterable.next())) {
     if (aResult.done) {
       break;
@@ -263,6 +266,7 @@ export function areSetsEqual(
     let hasMatch = false;
     let matchIndex = 0;
 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while ((bResult = bIterable.next())) {
       if (bResult.done) {
         break;

package/src/index.ts

@@ -3,9 +3,9 @@ import {
   createEqualityComparator,
   createInternalEqualityComparator,
   createIsEqual,
-} from './comparator';
-import type { CustomEqualCreatorOptions } from './internalTypes';
-import { sameValueZeroEqual } from './utils';
+} from './comparator.ts';
+import type { CustomEqualCreatorOptions } from './internalTypes.ts';
+import { sameValueZeroEqual } from './utils.ts';
 
 export { sameValueZeroEqual };
 export type {
@@ -25,7 +25,7 @@ export type {
   State,
   TypeEqualityComparator,
   TypedArray,
-} from './internalTypes';
+} from './internalTypes.ts';
 
 /**
  * Whether the items passed are deeply-equal in value.

package/src/internalTypes.ts

@@ -142,7 +142,7 @@ export type InternalEqualityComparator<Meta> = (
 ) => boolean;
 
 // We explicitly check for primitive wrapper types
-// eslint-disable-next-line @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
 export type PrimitiveWrapper = Boolean | Number | String;
 
 /**

package/src/utils.ts

@@ -5,7 +5,7 @@ import type {
   Dictionary,
   State,
   TypeEqualityComparator,
-} from './internalTypes';
+} from './internalTypes.ts';
 
 const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
 const { hasOwnProperty } = Object.prototype;
@@ -83,6 +83,7 @@ export function getStrictProperties(
  * Whether the object contains the property passed as an own property.
  */
 export const hasOwn =
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   Object.hasOwn ||
   ((object: Dictionary, property: number | string | symbol) =>
     hasOwnProperty.call(object, property));

package/.babelrc

@@ -1,34 +0,0 @@
-{
-  "env": {
-    "lib": {
-      "presets": [
-        [
-          "@babel/preset-env",
-          {
-            "loose": true
-          }
-        ]
-      ]
-    },
-    "test": {
-      "presets": [
-        [
-          "@babel/preset-env",
-          {
-            "loose": true
-          }
-        ]
-      ]
-    }
-  },
-  "presets": [
-    "@babel/preset-typescript",
-    [
-      "@babel/preset-env",
-      {
-        "loose": true,
-        "modules": false
-      }
-    ]
-  ]
-}

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "arrowParens": "always",
-  "bracketSpacing": true,
-  "semi": true,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "trailingComma": "all"
-}

package/.release-it.beta.json

@@ -1,18 +0,0 @@
-{
-  "github": {
-    "release": true,
-    "tagName": "v${version}"
-  },
-  "hooks": {
-    "before:init": [
-      "npm run typecheck",
-      "npm run lint",
-      "npm run test",
-      "npm run build"
-    ]
-  },
-  "npm": {
-    "tag": "next"
-  },
-  "preReleaseId": "beta"
-}

package/.release-it.json

@@ -1,14 +0,0 @@
-{
-  "github": {
-    "release": true,
-    "tagName": "v${version}"
-  },
-  "hooks": {
-    "before:init": [
-      "npm run typecheck",
-      "npm run lint",
-      "npm run test",
-      "npm run build"
-    ]
-  }
-}

package/.yarnrc.yml

@@ -1,5 +0,0 @@
-compressionLevel: mixed
-
-enableGlobalCache: false
-
-nodeLinker: node-modules

package/BUILD.md

@@ -1,37 +0,0 @@
-# Reproducing a build
-
-## Clone version
-
-```
-git clone https://github.com/planttheidea/fast-equals.git
-cd fast-equals
-git checkout {version}
-```
-
-Replace `{version}` above with the appropriate package version. If you want to compare a version older than `1.6.2`, you'll need to use a commit hash directly.
-
-## Install
-
-```
-yarn install
-```
-
-We use `yarn` for our package management, so to ensure that exact dependencies you should also use it.
-
-## Build artifacts
-
-```
-yarn run build
-```
-
-**NOTE**: To get an exact checksum match with the versions released on npm, it may be necessary to change line endings. For example, on Linux you might run:
-
-```
-unix2dos dist/fast-equals.min.js
-```
-
-## Get checksum
-
-```
-sha256sum dist/fast-equals.min.js
-```

package/config/rollup/config.base.js

@@ -1,49 +0,0 @@
-import commonjs from '@rollup/plugin-commonjs';
-import { nodeResolve } from '@rollup/plugin-node-resolve';
-import replace from '@rollup/plugin-replace';
-import typescript from '@rollup/plugin-typescript';
-import fs from 'fs';
-import path from 'path';
-import tsc from 'typescript';
-import { fileURLToPath } from 'url';
-
-const ROOT = fileURLToPath(new URL('../..', import.meta.url));
-
-export const PACKAGE_JSON = JSON.parse(
-  fs.readFileSync(path.resolve(ROOT, 'package.json')),
-);
-
-const external = [
-  ...Object.keys(PACKAGE_JSON.dependencies || {}),
-  ...Object.keys(PACKAGE_JSON.peerDependencies || {}),
-];
-const globals = external.reduce((globals, name) => {
-  globals[name] = name;
-
-  return globals;
-}, {});
-
-export const BASE_CONFIG = {
-  external,
-  input: path.resolve(ROOT, 'src', 'index.ts'),
-  output: {
-    exports: 'named',
-    globals,
-    name: 'fast-equals',
-    sourcemap: true,
-  },
-  plugins: [
-    replace({
-      'process.env.NODE_ENV': JSON.stringify('production'),
-      preventAssignment: true,
-    }),
-    nodeResolve({
-      mainFields: ['module', 'browser', 'main'],
-    }),
-    commonjs({ include: /use-sync-external-store/ }),
-    typescript({
-      tsconfig: path.resolve(ROOT, 'config', 'tsconfig', 'base.json'),
-      typescript: tsc,
-    }),
-  ],
-};

package/config/rollup/config.cjs.js

@@ -1,10 +0,0 @@
-import { BASE_CONFIG, PACKAGE_JSON } from './config.base.js';
-
-export default {
-  ...BASE_CONFIG,
-  output: {
-    ...BASE_CONFIG.output,
-    file: PACKAGE_JSON.main,
-    format: 'cjs',
-  },
-};

package/config/rollup/config.esm.js

@@ -1,10 +0,0 @@
-import { BASE_CONFIG, PACKAGE_JSON } from './config.base.js';
-
-export default {
-  ...BASE_CONFIG,
-  output: {
-    ...BASE_CONFIG.output,
-    file: PACKAGE_JSON.module,
-    format: 'es',
-  },
-};

package/config/rollup/config.min.js

@@ -1,13 +0,0 @@
-import { BASE_CONFIG, PACKAGE_JSON } from './config.base.js';
-import terser from '@rollup/plugin-terser';
-
-export default {
-  ...BASE_CONFIG,
-  output: {
-    ...BASE_CONFIG.output,
-    file: PACKAGE_JSON.browser.replace('umd', 'min'),
-    format: 'umd',
-    sourcemap: false,
-  },
-  plugins: [...BASE_CONFIG.plugins, terser()],
-};

package/config/rollup/config.umd.js

@@ -1,10 +0,0 @@
-import { BASE_CONFIG, PACKAGE_JSON } from './config.base.js';
-
-export default {
-  ...BASE_CONFIG,
-  output: {
-    ...BASE_CONFIG.output,
-    file: PACKAGE_JSON.browser,
-    format: 'umd',
-  },
-};

package/config/tsconfig/base.json

@@ -1,32 +0,0 @@
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "allowUnreachableCode": false,
-    "baseUrl": "../../src",
-    "esModuleInterop": true,
-    "jsx": "react-jsx",
-    "lib": ["DOM", "ESNext"],
-    "module": "ESNext",
-    "moduleResolution": "Node",
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitAny": true,
-    "noImplicitReturns": true,
-    "noImplicitThis": true,
-    "noUncheckedIndexedAccess": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "outDir": "../../../dist",
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "strict": true,
-    "strictBindCallApply": true,
-    "strictNullChecks": true,
-    "inlineSources": true,
-    "target": "es5",
-    "types": ["jest", "node", "react"]
-  },
-  "exclude": ["../../node_modules"],
-  "include": ["../../src/**/*", "../../__tests__/**/*", "../../DEV_ONLY/**/*"],
-  "files": ["../../node_modules/jest-expect-message/types/index.d.ts"]
-}

package/config/tsconfig/cjs.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./declarations.json",
-  "compilerOptions": {
-    "declarationDir": "../../dist/cjs/types",
-    "module": "CommonJS",
-    "outDir": "../../dist/cjs"
-  }
-}

package/config/tsconfig/declarations.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./base.json",
-  "compilerOptions": {
-    "declaration": true,
-    "emitDeclarationOnly": true,
-    "resolveJsonModule": false
-  },
-  "include": ["../../src/*"]
-}

package/config/tsconfig/esm.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./declarations.json",
-  "compilerOptions": {
-    "declarationDir": "../../dist/esm/types",
-    "module": "ESNext",
-    "outDir": "../../dist/esm"
-  }
-}

package/config/tsconfig/min.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./declarations.json",
-  "compilerOptions": {
-    "declarationDir": "../../dist/min/types",
-    "module": "UMD",
-    "outDir": "../../dist/min"
-  }
-}

package/config/tsconfig/umd.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./declarations.json",
-  "compilerOptions": {
-    "declarationDir": "../../dist/umd/types",
-    "module": "UMD",
-    "outDir": "../../dist/umd"
-  }
-}

package/config/webpack.config.js

@@ -1,57 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-
-import ESLintWebpackPlugin from 'eslint-webpack-plugin';
-import HtmlWebpackPlugin from 'html-webpack-plugin';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import webpack from 'webpack';
-
-const ROOT = fileURLToPath(new URL('..', import.meta.url));
-const PORT = 3000;
-
-export default {
-  cache: true,
-
-  devServer: {
-    host: 'localhost',
-    port: PORT,
-  },
-
-  devtool: 'source-map',
-
-  entry: [path.resolve(ROOT, 'DEV_ONLY', 'index.tsx')],
-
-  mode: 'development',
-
-  module: {
-    rules: [
-      {
-        include: [path.resolve(ROOT, 'src'), path.resolve(ROOT, 'DEV_ONLY')],
-        loader: 'ts-loader',
-        options: {
-          reportFiles: ['src/*.{ts|tsx}'],
-        },
-        test: /\.(ts|tsx)$/,
-      },
-    ],
-  },
-
-  output: {
-    filename: 'fast-equals.js',
-    library: 'fastEquals',
-    libraryTarget: 'umd',
-    path: path.resolve(ROOT, 'dist'),
-    publicPath: `http://localhost:${PORT}/`,
-    umdNamedDefine: true,
-  },
-
-  plugins: [
-    new ESLintWebpackPlugin(),
-    new webpack.EnvironmentPlugin(['NODE_ENV']),
-    new HtmlWebpackPlugin(),
-  ],
-
-  resolve: {
-    extensions: ['.tsx', '.ts', '.js'],
-  },
-};

package/recipes/explicit-property-check.md

@@ -1,26 +0,0 @@
-# Explicit property check
-
-Sometimes it is necessary to squeeze every once of performance out of your runtime code, and deep equality checks can be a bottleneck. When this is occurs, it can be advantageous to build a custom comparison that allows for highly specific equality checks.
-
-An example where you know the shape of the objects being passed in, where the `foo` property is a simple primitive and the `bar` property is a nested object:
-
-```ts
-import { createCustomEqual } from 'fast-equals';
-import type { TypeEqualityComparator } from 'fast-equals';
-
-interface SpecialObject {
-  foo: string;
-  bar: {
-    baz: number;
-  };
-}
-
-const areObjectsEqual: TypeEqualityComparator<SpecialObject, undefined> = (
-  a,
-  b,
-) => a.foo === b.foo && a.bar.baz === b.bar.baz;
-
-const isSpecialObjectEqual = createCustomEqual({
-  createCustomConfig: () => ({ areObjectsEqual }),
-});
-```

package/recipes/legacy-circular-equal-support.md

@@ -1,75 +0,0 @@
-# Legacy environment support for circular equal comparators
-
-Starting in `4.x.x`, `WeakMap` is expected to be available in the environment. All modern browsers support this global object, however there may be situations where a legacy environmental support is required (example: IE11). If you need to support such an environment and polyfilling is not an option, creating a custom comparator that uses a custom cache implementation with the same contract is a simple solution.
-
-```ts
-import { createCustomEqual, sameValueZeroEqual } from 'fast-equals';
-import type { Cache } from 'fast-equals';
-
-function getCache(): Cache<any, any> {
-  const entries: Array<[object, any]> = [];
-
-  return {
-    delete(key) {
-      for (let index = 0; index < entries.length; ++index) {
-        if (entries[index][0] === key) {
-          entries.splice(index, 1);
-          return true;
-        }
-      }
-
-      return false;
-    },
-
-    get(key) {
-      for (let index = 0; index < entries.length; ++index) {
-        if (entries[index][0] === key) {
-          return entries[index][1];
-        }
-      }
-    },
-
-    set(key, value) {
-      for (let index = 0; index < entries.length; ++index) {
-        if (entries[index][0] === key) {
-          entries[index][1] = value;
-          return this;
-        }
-      }
-
-      entries.push([key, value]);
-
-      return this;
-    },
-  };
-}
-
-interface Meta {
-  customMethod(): void;
-  customValue: string;
-}
-
-const meta = {
-  customMethod() {
-    console.log('hello!');
-  },
-  customValue: 'goodbye',
-};
-
-const circularDeepEqual = createCustomEqual<Cache>({
-  circular: true,
-  createState: () => ({
-    cache: getCache(),
-    meta,
-  }),
-});
-
-const circularShallowEqual = createCustomEqual<Cache>({
-  circular: true,
-  comparator: sameValueZeroEqual,
-  createState: () => ({
-    cache: getCache(),
-    meta,
-  }),
-});
-```

package/recipes/legacy-regexp-support.md

@@ -1,24 +0,0 @@
-# Legacy environment support for `RegExp` comparators
-
-Starting in `4.x.x`, `RegExp.prototype.flags` is expected to be available in the environment. All modern browsers support this feature, however there may be situations where a legacy environmental support is required (example: IE11). If you need to support such an environment and polyfilling is not an option, creating a custom comparator that uses a more verbose comparison of all possible flags is a simple solution.
-
-```ts
-import { createCustomEqual, sameValueZeroEqual } from 'deep-Equals';
-
-const areRegExpsEqual = (a: RegExp, b: RegExp) =>
-  a.source === b.source &&
-  a.global === b.global &&
-  a.ignoreCase === b.ignoreCase &&
-  a.multiline === b.multiline &&
-  a.unicode === b.unicode &&
-  a.sticky === b.sticky &&
-  a.lastIndex === b.lastIndex;
-
-const deepEqual = createCustomEqual({
-  createCustomConfig: () => ({ areRegExpsEqual }),
-});
-const shallowEqual = createCustomEqual({
-  comparator: sameValueZero,
-  createCustomConfig: () => ({ areRegExpsEqual }),
-});
-```

package/recipes/non-standard-properties.md

@@ -1,48 +0,0 @@
-# Non-standard properties
-
-Sometimes, objects require a comparison that extend beyond its own keys, or even its own properties or symbols. Using a custom object comparator with `createCustomEqual` allows these kinds of comparisons.
-
-```ts
-import { createCustomEqual } from 'fast-equals';
-import type { TypeEqualityComparator } from 'fast-equals';
-
-type AreObjectsEqual = TypeEqualityComparator<Record<any, any>, undefined>;
-
-class HiddenProperty {
-  visible: boolean;
-  #hidden: string;
-
-  constructor(value: string) {
-    this.visible = true;
-    this.#hidden = value;
-  }
-
-  get hidden() {
-    return this.#hidden;
-  }
-}
-
-function createAreObjectsEqual(
-  areObjectsEqual: AreObjectsEqual,
-): AreObjectsEqual {
-  return function (a, b, state) {
-    if (!areObjectsEqual(a, b, state)) {
-      return false;
-    }
-
-    const aInstance = a instanceof HiddenProperty;
-    const bInstance = b instanceof HiddenProperty;
-
-    if (aInstance || bInstance) {
-      return aInstance && bInstance && a.hidden === b.hidden;
-    }
-
-    return true;
-  };
-}
-
-const deepEqual = createCustomEqual({
-  createCustomConfig: ({ areObjectsEqual }) =>
-    createAreObjectsEqual(areObjectsEqual),
-});
-```

package/recipes/special-objects.md

@@ -1,25 +0,0 @@
-# Handling special (built-in) objects
-
-The `createCustomEqual` uses `@@toStringTag` to decide which well-known comparator to call. However, some values might not fit either of them. For example `WeakMap` is compared intentionally. Additionally, it's possible that new built-in objects are added to the language. Third parties might also add `@@toStringTag` to their objects.
-
-For example the [TC39 Temporal spec](https://tc39.es/proposal-temporal/docs/) requires `@@toStringTag` being implemetend and the polyfills do that. Passing `areObjectsEqual` will not work in that scenario. Instead you'll have to register a handler for the tag instead.
-
-```ts
-import { createCustomEqual } from 'fast-equals';
-import type { TypeEqualityComparator } from 'fast-equals';
-
-const areZonedDateTimesEqual: TypeEqualityComparator<unknown, undefined> = (
-  a,
-  b,
-) => a instanceof Temporal.ZonedDateTime
-  && b instanceof Temporal.ZonedDateTime
-  && a.equals(b);
-
-const isSpecialObjectEqual = createCustomEqual({
-  createCustomConfig: () => ({
-    unknownTagComparators: {
-      "Temporal.ZonedDateTime", areZonedDateTimesEqual,
-    }
-  }),
-});
-```