Updated template

- Updated dependencies
- Provided example usage of fast-check
- Added gitattributes for compatibility with microsoft

Author: alexrecuenco

.eslintrc.js

@@ -30,10 +30,12 @@ module.exports = {
   },
   rules: {
     'import/no-extraneous-dependencies': warn,
+
     // Temporal?
     'no-console': warn,
     'no-return-await': warn,
-    'no-unused-vars': warn,
+    'no-unused-vars': off,
+    '@typescript-eslint/no-unused-vars': off,
     eqeqeq: [error, 'smart'],
     'no-else-return': [
       error,
@@ -63,6 +65,9 @@ module.exports = {
     '@typescript-eslint/indent': off,
     '@typescript-eslint/explicit-member-accessibility': warn,
     '@typescript-eslint/no-explicit-any': off,
+    '@typescript-eslint/no-unsafe-return': off,
+    '@typescript-eslint/no-unsafe-assignment': off,
+    '@typescript-eslint/explicit-function-return-type': off,
     '@typescript-eslint/no-var-requires': off,
     '@typescript-eslint/no-empty-function': off,
     '@typescript-eslint/no-object-literal-type-assertion': off,
@@ -71,16 +76,7 @@ module.exports = {
   overrides: [
     {
       files: ['*.ts', '*.tsx'],
-      rules: {
-        '@typescript-eslint/explicit-function-return-type': [
-          error,
-          {
-            allowExpressions: true,
-            allowTypedFunctionExpressions: true,
-            allowHigherOrderFunctions: true,
-          },
-        ],
-      },
+      rules: {},
     },
     {
       // TESTING CONFIGURATION
@@ -105,6 +101,7 @@ module.exports = {
       // "extends": ["plugin:jest/recommended"]
       plugins: ['jest'],
       rules: {
+        'no-restricted-imports': off,
         'jest/no-disabled-tests': warn,
         'jest/no-focused-tests': error,
         'jest/no-identical-title': error,

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

__tests__/datetime.test.ts

@@ -0,0 +1,66 @@
+import fc, { Arbitrary } from 'fast-check';
+import { replace } from '../src';
+
+const EachSimpleType = [
+  ['string', fc.string()],
+  ['integers', fc.integer()],
+] as const;
+
+describe.each(EachSimpleType)('Simple replacements works for %p', (_, arb: Arbitrary<any>) => {
+  test('Should replace simple types', () => {
+    fc.assert(
+      fc.property(arb, fc.func(arb), (s, f) => {
+        return replace(f, (t: string): t is any => true)(s) === f(s);
+      }),
+    );
+  });
+});
+
+describe.each(EachSimpleType)('Simple replacements works for arrays of %p', (_, arb: Arbitrary<any>) => {
+  test('Should replace only elements', () => {
+    fc.assert(
+      fc.property(fc.array(arb), fc.func(arb), (arr, f) => {
+        const obtainedResult = replace(f, (t): t is any => !Array.isArray(t))(arr);
+        const realResult = arr.map((v) => f(v));
+        expect(obtainedResult).toStrictEqual(realResult);
+      }),
+    );
+  });
+});
+
+describe.each(EachSimpleType)('Simple replacements works for objects of %p', (_, arb: Arbitrary<any>) => {
+  test('Should replace only properties', () => {
+    fc.assert(
+      fc.property(fc.dictionary(fc.string(), arb), fc.func(arb), (obj, f) => {
+        const realResult = Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, f(v)]));
+        const obtainedResult = replace(f, (t): t is any => !Array.isArray(t) && typeof t !== 'object')(obj);
+
+        expect(obtainedResult).toStrictEqual(realResult);
+      }),
+    );
+  });
+});
+
+describe('Ignoring values', () => {
+  const f = (v: any) => {
+    throw new Error();
+  };
+  test('should leave json objects alone', () => {
+    const throwOnReplace = replace(f, (t): t is any => false);
+    fc.assert(
+      fc.property(fc.jsonObject(), (json) => {
+        expect(() => expect(throwOnReplace(json)).toStrictEqual(json)).not.toThrow();
+      }),
+    );
+  });
+
+  test('Should leave numbers unchanged when searching for strings', () => {
+    const throwOnReplace = replace(f, (t): t is string => typeof t === 'string');
+    const objectArbitrary = fc.object({ maxDepth: 4, withTypedArray: true, values: [fc.integer()] });
+    fc.assert(
+      fc.property(objectArbitrary, (obj) => {
+        expect(() => throwOnReplace(obj)).not.toThrow();
+      }),
+    );
+  });
+});