fast-equals 5.3.0 → 5.3.2

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,
-    }
-  }),
-});
-```

package/recipes/using-meta-in-comparison.md

@@ -1,20 +0,0 @@
-# Using `meta` in comparison
-
-Sometimes a "pure" equality between two objects is insufficient, because the comparison relies on some external state. While these kinds of scenarios should generally be avoided, it is possible to handle them with a custom internal comparator that checks `meta` values.
-
-```ts
-import { createCustomEqual } from 'fast-equals';
-
-interface Meta {
-  value: string;
-}
-
-const meta: Meta = { value: 'baz' };
-
-const deepEqual = createCustomEqual<Meta>({
-  createInternalComparator:
-    (compare) => (a, b, _keyA, _keyB, _parentA, _parentB, state) =>
-      compare(a, b, state) || a === state.meta.value || b === state.meta.value,
-  createState: () => ({ meta }),
-});
-```

package/scripts/apply-type-file-extensions.mjs

@@ -1,33 +0,0 @@
-import glob from 'fast-glob';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const IMPORT_STATEMENT_REGEXP =
-  /import([ \n\t]*(?:[^ \n\t\{\}]+[ \n\t]*,?)?(?:[ \n\t]*\{(?:[ \n\t]*[^ \n\t"'\{\}]+[ \n\t]*,?)+\})?[ \n\t]*)from[ \n\t]*(['"])([^'"\n]+)(?:['"])/g;
-
-const EXPORT_STATEMENT_REGEXP =
-  /export([ \n\t]*(?:[^ \n\t\{\}]+[ \n\t]*,?)?(?:[ \n\t]*\{(?:[ \n\t]*[^ \n\t"'\{\}]+[ \n\t]*,?)+\})?[ \n\t]*)from[ \n\t]*(['"])([^'"\n]+)(?:['"])/g;
-
-const files = glob.sync(
-  join(import.meta.dirname, '..', 'dist', '*', 'types', '*.d.ts'),
-);
-
-function getReplacement(type) {
-  return function (line, dependencies, _quoteType, location) {
-    const extension = line.startsWith(`${type} type`) ? 'd.ts' : 'ts';
-
-    return `${type}${dependencies}from '${location}.${extension}'`;
-  };
-}
-
-function getReplacedContents(contents) {
-  return contents
-    .replaceAll(IMPORT_STATEMENT_REGEXP, getReplacement('import'))
-    .replaceAll(EXPORT_STATEMENT_REGEXP, getReplacement('export'));
-}
-
-for (const file of files) {
-  const contents = readFileSync(file, 'utf-8');
-
-  writeFileSync(file, getReplacedContents(contents), 'utf-8');
-}

package/scripts/fallback-types.mjs

@@ -1,64 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-const METHODS = `
-/**
- * Whether the values passed are strictly equal or both NaN.
- */
-export declare const sameValueZeroEqual: <A, B>(a: A, b: B) => boolean;
-
-/**
- * Whether the items passed are deeply-equal in value.
- */
-export declare const deepEqual: <A, B>(a: A, b: B) => boolean;
-/**
- * Whether the items passed are deeply-equal in value based on strict comparison.
- */
-export declare const strictDeepEqual: <A, B>(a: A, b: B) => boolean;
-/**
- * Whether the items passed are deeply-equal in value, including circular references.
- */
-export declare const circularDeepEqual: <A, B>(a: A, b: B) => boolean;
-/**
- * Whether the items passed are deeply-equal in value, including circular references,
- * based on strict comparison.
- */
-export declare const strictCircularDeepEqual: <A, B>(a: A, b: B) => boolean;
-/**
- * Whether the items passed are shallowly-equal in value.
- */
-export declare const shallowEqual: <A, B>(a: A, b: B) => boolean;
-/**
- * Whether the items passed are shallowly-equal in value based on strict comparison
- */
-export declare const strictShallowEqual: <A, B>(a: A, b: B) => boolean;
-/**
- * Whether the items passed are shallowly-equal in value, including circular references.
- */
-export declare const circularShallowEqual: <A, B>(a: A, b: B) => boolean;
-/**
- * Whether the items passed are shallowly-equal in value, including circular references,
- * based on strict comparison.
- */
-export declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
-/**
- * Create a custom equality comparison method.
- *
- * This can be done to create very targeted comparisons in extreme hot-path scenarios
- * where the standard methods are not performant enough, but can also be used to provide
- * support for legacy environments that cannot polyfill for modern features expected by
- * \`fast-equals\`, such as \`WeakMap\` or \`RegExp.prototype.flags\`.
- */
-export declare function createCustomEqual<Meta = undefined>(
-  options?: CustomEqualCreatorOptions<Meta>,
-): <A, B>(a: A, b: B) => boolean;
-`;
-
-const INTERNAL_TYPES = fs.readFileSync(
-  path.join(import.meta.dirname, '..', 'src', 'internalTypes.ts'),
-);
-
-const OUTPUT = `${INTERNAL_TYPES}\n${METHODS}`.trim();
-const OUTPUT_DESTINATION = path.join(import.meta.dirname, '..', 'index.d.ts');
-
-fs.writeFileSync(OUTPUT_DESTINATION, OUTPUT, 'utf-8');