jfather 0.3.0 → 0.5.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Sébastien Règne
+Copyright (c) 2024-2026 Sébastien Règne
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,20 +2,24 @@
 
 <!-- Utiliser du HTML (avec l'attribut "align" obsolète) pour faire flotter
      l'image à droite. -->
-<!-- markdownlint-disable-next-line no-inline-html-->
-<img src="asset/logo.svg" align="right" alt="">
+<!-- markdownlint-disable-next-line no-inline-html -->
+<img src="asset/logo.svg" align="right" width="100" height="100" alt="">
 
-[![npm][img-npm]][link-npm]
-[![build][img-build]][link-build]
-[![coverage][img-coverage]][link-coverage]
-[![semver][img-semver]][link-semver]
+[![npm][img-npm]][link-npm] [![build][img-build]][link-build]
+[![coverage][img-coverage]][link-coverage] [![semver][img-semver]][link-semver]
 
 > _Boys use JSON; Men use JFather._
 
 ## Overview
 
-JFather is a utility library to **merge**, **extend** and **override**
-[JSON](https://www.json.org/json-en.html "JavaScript Object Notation") objects.
+JFather is a
+[JSON](https://www.json.org/json-en.html "JavaScript Object Notation") utility
+library to:
+
+- [**merge**](#merge) deeply two JSON objects.
+- [**extend**](#extend) a JSON objects with `"$extends"` property.
+- [**override**](#override) an array with `"$foo[0]"` (replace a value) or
+  `"$foo[]"` (append values) properties.
 
 <!-- prettier-ignore-start -->
 ```javascript
@@ -48,8 +52,8 @@ console.log(extended);
 //   "quote": "With great fist comes great KO"
 // }
 
-// Override an object.
-const overridden = await JFather.merge(
+// Override arrays of an object.
+const overridden = JFather.merge(
   { "foo": ["a", "alpha"] },
   { "$foo[0]": "A", "$foo[]": ["BETA"] }
 );
@@ -89,7 +93,7 @@ JFather is published on [npm][link-npm] (its CDN:
 [esm.sh](https://esm.sh/jfather),
 [jsDelivr](https://www.jsdelivr.com/package/npm/jfather),
 [UNPKG](https://unpkg.com/browse/jfather/)) and
-[Deno](https://deno.land/x/jfather).
+[JSR](https://jsr.io/@regseb/jfather).
 
 ```javascript
 // Node.js and Bun (after `npm install jfather`):
@@ -100,263 +104,308 @@ import JFather from "https://esm.sh/jfather@0";
 import JFather from "https://cdn.jsdelivr.net/npm/jfather@0";
 import JFather from "https://unpkg.com/jfather@0";
 
-// Deno:
-import JFather from "https://deno.land/x/jfather/mod.js";
+// Deno (after `deno add jsr:@regseb/jfather`):
+import JFather from "jsr:@regseb/jfather";
 ```
 
 ## Features
 
 ### Merge
 
-<!-- markdownlint-disable no-inline-html -->
-<table>
-  <tr>
-    <th><code>parent</code></th>
-    <th><code>child</code></th>
-    <th><code>JFather.merge(parent, child)</code></th>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>1</code></pre></td>
-    <td><pre lang="json"><code>2</code></pre></td>
-    <td><pre lang="json"><code>2</code></pre></td>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "foo": "alpha",
-  "bar": "ALPHA"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "foo": "beta",
-  "baz": "BETA"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "foo": "beta",
-  "bar": "ALPHA",
-  "baz": "BETA"
-}</code></pre></td>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "foo": [1, 10, 11]
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "foo": [2, 20, 22]
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "foo": [2, 20, 22]
-}</code></pre></td>
-  </tr>
-</table>
-<!-- markdownlint-enable no-inline-html -->
+With any two variable types (except objects), merge returns the value of the
+child. The following example shows how to use it with numbers: the result is `2`
+(retrieved from the child value).
+
+```javascript
+const parent = 1;
+const child = 2;
+console.log(JFather.merge(parent, child));
+// 2
+```
+
+If both variables are objects, the object properties are merged one by one. In
+this example, the `"foo"` property overwrites that of the parent. The properties
+`"bar"` and `"baz"` are simply copied, as they are only in either the parent or
+the child.
+
+<!-- prettier-ignore-start -->
+```javascript
+const parent = { "foo": "alpha", "bar": "ALPHA" };
+const child  = { "foo": "beta", "baz": "BETA" };
+console.log(JFather.merge(parent, child));
+// { "foo": "beta", "bar": "ALPHA", "baz": "BETA" }
+```
+<!-- prettier-ignore-end -->
+
+Merging is done recursively. The following example shows the merging of two
+objects, which in turn contains the merging of the `"foo"` sub-objects.
+
+<!-- prettier-ignore-start -->
+```javascript
+const parent = {
+  "foo": { "bar": 1, "baz": 2 },
+  "qux": "a"
+};
+const child = {
+  "foo": { "bar": 10, "quux": 20 },
+  "corge": "b"
+};
+console.log(JFather.merge(parent, child));
+// {
+//   "foo": { "bar": 10, "baz": 2, "quux": 20 },
+//   "qux": "a",
+//   "corge": "b"
+// }
+```
+<!-- prettier-ignore-end -->
+
+Arrays are processed like any other type: the value of the child overrides that
+of the parent. For more detailed merging, see the [_Override_](#override)
+chapter, which shows how to merge arrays.
+
+<!-- prettier-ignore-start -->
+```javascript
+const parent = { "foo": [1, 10, 11] };
+const child  = { "foo": [2, 20, 22] };
+console.log(JFather.merge(parent, child));
+// { "foo": [2, 20, 22] }
+```
+<!-- prettier-ignore-end -->
 
 ### Extend
 
-<!-- markdownlint-disable no-inline-html -->
-<table>
-  <tr>
-    <th><code>https://foo.bar/parent.json</code></th>
-    <th><code>child</code></th>
-    <th><code>await JFather.extend(child)</code></th>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "baz": "qux"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "$extends": "https://foo.bar/parent.json"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "baz": "qux"
-}</code></pre></td>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "baz": "qux"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "$extends": "https://foo.bar/parent.json",
-  "baz": "quux"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "baz": "quux"
-}</code></pre></td>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "baz": "qux"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "$extends": "https://foo.bar/parent.json",
-  "quux": "corge"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "baz": "qux",
-  "quux": "corge"
-}</code></pre></td>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "baz": "qux"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "quux": {
-    "$extends": "https://foo.bar/parent.json",
-    "corge": "grault"
-  }
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "quux": {
-    "baz": "qux",
-    "corge": "grault"
+You can extend an object using the `"$extends"` property, which must link to a
+JSON file. The remote JSON file and the current object will be merged.
+
+In this example, the child object is empty (except for the `"$extends"`
+property). The result therefore contains the parent object.
+
+<!-- prettier-ignore-start -->
+```javascript
+// https://example.com/parent.json
+// { "foo": 42 }
+
+const obj = { "$extends": "https://example.com/parent.json" };
+console.log(await JFather.extend(obj));
+// { "foo": 42 }
+```
+<!-- prettier-ignore-end -->
+
+As with merge, if a property is in both parent and child, the child's value is
+used. Otherwise, both parent and child properties are added to the result.
+
+<!-- prettier-ignore-start -->
+```javascript
+// https://example.com/parent.json
+// { "foo": "A", "bar": "Alpha" }
+
+const obj = {
+  "$extends": "https://example.com/parent.json",
+  "foo": "B",
+  "baz": "Beta"
+};
+console.log(await JFather.extend(obj));
+// { "foo": "B", "bar": "Alpha", "baz": "Beta" }
+```
+<!-- prettier-ignore-end -->
+
+It is possible to extend a child's sub-object. In the example below, the parent
+is merged with the child's `"bar"` sub-object.
+
+<!-- prettier-ignore-start -->
+```javascript
+// https://example.com/parent.json
+// { "foo": 42 }
+
+const obj = {
+  "bar": {
+    "$extends": "https://example.com/parent.json",
+    "baz": 3.14
   }
-}</code></pre></td>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "baz": {
-    "qux": [1, 2],
-    "quux": "a"
-  },
-  "corge": true
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "$extends": "https://foo.bar/parent.json#baz"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "qux": [1, 2],
-  "quux": "a"
-}</code></pre></td>
-  </tr>
-</table>
-<!-- markdownlint-enable no-inline-html -->
+};
+console.log(await JFather.extend(obj));
+// {
+//   "bar": { "foo": 42, "baz": 3.14 }
+// }
+```
+<!-- prettier-ignore-end -->
+
+In the parent link, you can define a path to retrieve a sub-object from the
+parent. The path is set in the URL hash:
+
+- `#foo`: the value of the `"foo"` property;
+- `#foo.bar`: the value of the `"bar"` sub-property in the `"foo"` property;
+- `#foo[42]`: the value of the forty-third array element in the `"foo"`
+  property;
+- `#foo[0].bar`: the value of the sub-property `"bar"` in the first element of
+  the array in the property `"foo"`.
+
+This example merges the `"foo"` property of the parent with the child.
+
+<!-- prettier-ignore-start -->
+```javascript
+// https://example.com/parent.json
+// {
+//   "foo": { "bar": [1, 2], "baz": "a" },
+//   "qux": true
+// }
+
+const obj = { "$extends": "https://example.com/parent.json#foo" };
+console.log(await JFather.extend(obj));
+// { "bar": [1, 2], "baz": "a" }
+```
+<!-- prettier-ignore-end -->
 
 ### Override
 
-<!-- markdownlint-disable no-inline-html -->
-<table>
-  <tr>
-    <th><code>parent</code></th>
-    <th><code>child</code></th>
-    <th><code>JFather.merge(parent, child)</code></th>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "foo": ["a", "Alpha"]
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "$foo[]": ["b", "Beta"]
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "foo": ["a", "Alpha", "b", "Beta"]
-}</code></pre></td>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
-  "foo": ["a", "Alpha"]
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "$foo[0]": "A"
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "foo": ["A", "Alpha"]
-}</code></pre></td>
-  </tr>
-  <tr>
-    <td><pre lang="json"><code>{
+If an object has arrays, the merge overwrites the parent's array with the
+child's. With the properties `"$foo[42]"` and `"$foo[]"`, you can refine the
+merge.
+
+In this example, the array `"foo"` is not overwritten. The first value of the
+`"foo"` array is merged with the value of the child's `"$foo[0]"` property. And
+the second value of `"foo"` is copied into the result.
+
+<!-- prettier-ignore-start -->
+```javascript
+const parent = { "foo": ["a", "Alpha"] };
+const child  = { "$foo[0]": "B" };
+console.log(JFather.merge(parent, child));
+// { "foo": ["B", "Alpha"] }
+```
+<!-- prettier-ignore-end -->
+
+With `"$foo[]"`, the child's values are added to those of the parent. In the
+example below, the values `"b"` and `"Beta"` are added to the array of the
+`"foo"` property.
+
+<!-- prettier-ignore-start -->
+```javascript
+const parent = { "foo": ["a", "Alpha"] };
+const child  = { "$foo[]": ["b", "Beta"] };
+console.log(JFather.merge(parent, child));
+// { "foo": ["a", "Alpha", "b", "Beta"] }
+```
+<!-- prettier-ignore-end -->
+
+You can combine the two overloads to, for example:
+
+- merge the first value of the parent's `"foo"` array with the value of the
+  child's `"$foo[0]"` property;
+- add the values `"b"` and `"c"` to the array of the sub-property `"bar"`.
+
+<!-- prettier-ignore-start -->
+```javascript
+const parent = {
   "foo": [{
     "bar": ["a"]
   }]
-}</code></pre></td>
-    <td><pre lang="json"><code>{
+};
+const child = {
   "$foo[0]": {
     "$bar[]": ["b", "c"]
   }
-}</code></pre></td>
-    <td><pre lang="json"><code>{
-  "foo": [{
-    "bar": ["a", "b", "c"]
-  }]
-}</code></pre></td>
-  </tr>
-</table>
-<!-- markdownlint-enable no-inline-html -->
+};
+console.log(JFather.merge(parent, child));
+// {
+//   "foo": [{
+//     "bar": ["a", "b", "c"]
+//   }]
+// }
+```
+<!-- prettier-ignore-end -->
+
+If the child overloads a property that does not exist in the parent, the
+overload is ignored. The overload is also ignored if the parent object is not an
+array. In the following example, the child has two overloads which are ignored:
+the overload on the property `"bar"` which is not an array, and the overload on
+`"baz"` which does not exist in the parent.
+
+<!-- prettier-ignore-start -->
+```javascript
+const parent = { "foo": ["a", "A"], "bar": 42 };
+const child  = { "$bar[0]": 3.14, "$baz[]": ["beta"] };
+console.log(JFather.merge(parent, child));
+// { "foo": ["a", "A"], "bar": 42 }
+```
+<!-- prettier-ignore-end -->
 
 ## API
 
-- [`merge()`](#merge)
-- [`extend()`](#extend)
-- [`load()`](#load)
-- [`parse()`](#parse)
+- [`JFather.merge(parent, child)`](#jfathermergeparent-child)
+- [`JFather.extend(obj, [options])`](#jfatherextendobj-options)
+- [`JFather.load(url, [options])`](#jfatherloadurl-options)
+- [`JFather.parse(text, [options])`](#jfatherparsetext-options)
 
-### `merge()`
+### `JFather.merge(parent, child)`
 
 Merge and override `parent` with `child`.
 
-```javascript
-JFather.merge(parent, child);
-```
-
 - Parameters:
-  - `parent`: The parent object.
-  - `child`: The child object.
-- Returns: The merged object.
+  - `parent` [`<any>`][mdn-any] The parent object.
+  - `child` [`<any>`][mdn-any] The child object.
+- Returns: [`<any>`][mdn-any] The merged object.
 
-### `extend()`
+### `JFather.extend(obj, [options])`
 
 Extend `obj`, merge and override.
 
-```javascript
-JFather.extend(obj, [options]);
-```
-
 - Parameter:
-  - `obj`: The object with any `$extends` properties.
-  - `options`:
-    - `request`: The function for getting a JSON object remotely. By default,
-      the object is got with
-      [`fetch()`](https://developer.mozilla.org/Web/API/fetch) and
-      [`Response.json()`](https://developer.mozilla.org/Web/API/Response/json).
-- Returns: A promise with the extended object.
+  - `obj` [`<any>`][mdn-any] The object with any `$extends` properties.
+  - `options` [`<Object>`][mdn-object]
+    - `request` [`<Function>`][mdn-function] The function for getting a JSON
+      object remotely. By default, the object is got with [`fetch()`][mdn-fetch]
+      and [`Response.json()`][mdn-response-json].
+- Returns: [`<Promise>`][mdn-promise] A promise with the extended object.
 
-### `load()`
+### `JFather.load(url, [options])`
 
-Load from a `url`, extend, merge and override.
-
-```javascript
-JFather.load(url, [options]);
-```
+Load from an `url`, extend, merge and override.
 
 - Parameter:
-  - `url`: The string containing the URL of a JSON file.
-  - `options`:
-    - `request`: The function for getting a JSON object remotely. By default,
-      the object is got with
-      [`fetch()`](https://developer.mozilla.org/Web/API/fetch) and
-      [`Response.json()`](https://developer.mozilla.org/Web/API/Response/json).
-- Returns: A promise with the loaded object.
+  - `url` [`<String>`][mdn-string] | [`<URL>`][mdn-url] The string containing
+    the URL of a JSON file.
+  - `options` [`<Object>`][mdn-object]
+    - `request` [`<Function>`][mdn-function] The function for getting a JSON
+      object remotely. By default, the object is got with [`fetch()`][mdn-fetch]
+      and [`Response.json()`][mdn-response-json].
+- Returns: [`<Promise>`][mdn-promise] A promise with the loaded object.
 
-### `parse()`
+### `JFather.parse(text, [options])`
 
 Parse a `text`, extend, merge and override.
 
-```javascript
-JFather.parse(text, [options]);
-```
-
 - Parameter:
-  - `text`: The string containing a JSON object.
-  - `options`:
-    - `request`: The function for getting a JSON object remotely. By default,
-      the object is got with
-      [`fetch()`](https://developer.mozilla.org/Web/API/fetch) and
-      [`Response.json()`](https://developer.mozilla.org/Web/API/Response/json).
-- Returns: A promise with the parsed object.
-
-[img-npm]: https://img.shields.io/npm/dm/jfather?label=npm&logo=npm&logoColor=whitesmoke
-[img-build]: https://img.shields.io/github/actions/workflow/status/regseb/jfather/ci.yml?branch=main&logo=github&logoColor=whitesmoke
-[img-coverage]: https://img.shields.io/endpoint?label=coverage&url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2Fregseb%2Fjfather%2Fmain
-[img-semver]: https://img.shields.io/badge/semver-2.0.0-blue?logo=semver&logoColor=whitesmoke
+  - `text` [`<String>`][mdn-string] The string containing a JSON object.
+  - `options` [`<Object>`][mdn-object]
+    - `request` [`<Function>`][mdn-function] The function for getting a JSON
+      object remotely. By default, the object is got with [`fetch()`][mdn-fetch]
+      and [`Response.json()`][mdn-response-json].
+- Returns: [`<Promise>`][mdn-promise] A promise with the parsed object.
+
+[mdn-any]: https://developer.mozilla.org/Web/JavaScript/Data_structures
+[mdn-function]:
+  https://developer.mozilla.org/JavaScript/Reference/Global_Objects/Function
+[mdn-object]:
+  https://developer.mozilla.org/JavaScript/Reference/Global_Objects/Object
+[mdn-promise]:
+  https://developer.mozilla.org/JavaScript/Reference/Global_Objects/Promise
+[mdn-string]:
+  https://developer.mozilla.org/JavaScript/Reference/Global_Objects/String
+[mdn-fetch]: https://developer.mozilla.org/Web/API/fetch
+[mdn-response-json]: https://developer.mozilla.org/Web/API/Response/json
+[mdn-url]: https://developer.mozilla.org/Web/API/URL
+[img-npm]:
+  https://img.shields.io/npm/dm/jfather?label=npm&logo=npm&logoColor=whitesmoke
+[img-build]:
+  https://img.shields.io/github/actions/workflow/status/regseb/jfather/ci.yml?branch=main&logo=github&logoColor=whitesmoke
+[img-coverage]:
+  https://img.shields.io/endpoint?label=coverage&url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2Fregseb%2Fjfather%2Fmain
+[img-semver]:
+  https://img.shields.io/badge/semver-2.0.0-blue?logo=semver&logoColor=whitesmoke
 [link-npm]: https://www.npmjs.com/package/jfather
-[link-build]: https://github.com/regseb/jfather/actions/workflows/ci.yml?query=branch%3Amain
-[link-coverage]: https://dashboard.stryker-mutator.io/reports/github.com/regseb/jfather/main
+[link-build]:
+  https://github.com/regseb/jfather/actions/workflows/ci.yml?query=branch%3Amain
+[link-coverage]:
+  https://dashboard.stryker-mutator.io/reports/github.com/regseb/jfather/main
 [link-semver]: https://semver.org/spec/v2.0.0.html "Semantic Versioning 2.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jfather",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "JSON with merge, extend and override.",
   "keywords": [
     "jfather",
@@ -35,50 +35,59 @@
   },
   "main": "./src/index.js",
   "types": "./types/index.d.ts",
-  "repository": "regseb/jfather",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/regseb/jfather.git"
+  },
   "type": "module",
   "scripts": {
+    "prepare": "tsc --project .tsconfig_types.json",
     "lint": "metalint",
     "lint:fix": "metalint --fix",
     "lint:types": "tsc --project .tsconfig_lint.json",
     "test": "npm run test:coverage",
-    "test:unit": "mocha --config test/mocharc.json",
+    "test:unit": "npm run test:unit:node",
+    "test:unit:node": "node --test --import ./test/polyfills/node.js 'test/unit/**/*.test.js'",
+    "test:unit:bun": "bun test --preload ./test/polyfills/bun.js test/unit/",
     "test:coverage": "stryker run",
     "jsdocs": "typedoc --tsconfig .tsconfig_jsdocs.json",
-    "prepare": "tsc --project .tsconfig_types.json",
     "clean": "node .script/clean.js"
   },
   "devDependencies": {
-    "@prantlf/jsonlint": "14.0.3",
-    "@prettier/plugin-xml": "3.4.1",
-    "@stryker-mutator/core": "8.2.6",
-    "@stryker-mutator/mocha-runner": "8.2.6",
-    "@types/mocha": "10.0.6",
-    "@types/node": "20.12.12",
-    "@types/sinon": "17.0.3",
-    "eslint": "8.57.0",
-    "eslint-plugin-array-func": "4.0.0",
+    "@biomejs/js-api": "4.0.0",
+    "@biomejs/wasm-nodejs": "2.3.11",
+    "@prantlf/jsonlint": "17.0.0",
+    "@prettier/plugin-xml": "3.4.2",
+    "@secretlint/secretlint-rule-github": "11.2.5",
+    "@secretlint/secretlint-rule-npm": "11.2.5",
+    "@stryker-mutator/core": "9.4.0",
+    "@stryker-mutator/tap-runner": "9.4.0",
+    "@types/bun": "1.3.5",
+    "@types/node": "25.0.3",
+    "eslint": "9.39.2",
+    "eslint-plugin-array-func": "5.1.0",
     "eslint-plugin-eslint-comments": "3.2.0",
-    "eslint-plugin-import": "2.29.1",
-    "eslint-plugin-jsdoc": "48.2.5",
-    "eslint-plugin-mocha": "10.4.3",
-    "eslint-plugin-n": "17.7.0",
-    "eslint-plugin-no-unsanitized": "4.0.2",
-    "eslint-plugin-promise": "6.1.1",
-    "eslint-plugin-regexp": "2.6.0",
-    "eslint-plugin-unicorn": "53.0.0",
-    "markdownlint": "0.34.0",
-    "metalint": "0.17.0",
-    "mocha": "10.4.0",
-    "npm-package-json-lint": "7.1.0",
-    "prettier": "3.2.5",
-    "publint": "0.2.8",
-    "sinon": "18.0.0",
-    "typedoc": "0.25.13",
-    "typescript": "5.4.5",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-jsdoc": "61.5.0",
+    "eslint-plugin-mocha": "11.2.0",
+    "eslint-plugin-n": "17.23.1",
+    "eslint-plugin-no-unsanitized": "4.1.4",
+    "eslint-plugin-promise": "7.2.1",
+    "eslint-plugin-regexp": "2.10.0",
+    "eslint-plugin-unicorn": "62.0.0",
+    "globals": "17.0.0",
+    "jsr": "0.13.5",
+    "markdownlint": "0.40.0",
+    "metalint": "0.21.2",
+    "npm-package-json-lint": "9.1.0",
+    "prettier": "3.7.4",
+    "publint": "0.3.16",
+    "secretlint": "11.2.5",
+    "typedoc": "0.28.15",
+    "typescript": "5.9.3",
     "yaml-lint": "1.7.0"
   },
   "engines": {
-    "node": ">=20.6.0"
+    "node": ">=20.18.0"
   }
 }

package/src/index.js

@@ -6,4 +6,8 @@
 
 import { extend, load, merge, parse } from "./jfather.js";
 
+/**
+ * @typedef {import('./jfather.js').Options} Options
+ */
+
 export default { extend, load, merge, parse };

package/src/jfather.js

@@ -10,8 +10,7 @@
  * @typedef {Object} Options
  * @prop {Function} [request] La fonction pour récupérer un objet JSON à
  *                            distance. Par défaut, l'objet est récupéré avec
- *                            <code>fetch()</code> et
- *                            <code>Response.prototype.json()</code>
+ *                            `fetch()` et `Response.json()`.
  */
 
 /**
@@ -22,7 +21,7 @@
  * @param {Function} fn  La fonction appliquée sur tous les objets.
  * @returns {any} Le retour de la fonction.
  */
-export const walk = function (obj, fn) {
+export const walk = (obj, fn) => {
     if (Object === obj?.constructor) {
         return fn(
             Object.fromEntries(
@@ -46,7 +45,7 @@ export const walk = function (obj, fn) {
  * @param {Function} fn  La fonction asynchrone appliquée sur tous les objets.
  * @returns {Promise<any>} Une promesse contenant le retour de la fonction.
  */
-export const walkAsync = async function (obj, fn) {
+export const walkAsync = async (obj, fn) => {
     if (Object === obj?.constructor) {
         return await fn(
             Object.fromEntries(
@@ -73,7 +72,7 @@ export const walkAsync = async function (obj, fn) {
  * @param {any} obj Une variable quelconque.
  * @returns {any} Le clone de la variable d'entrée.
  */
-export const clone = function (obj) {
+export const clone = (obj) => {
     return walk(obj, (/** @type {any} */ v) => v);
 };
 
@@ -85,16 +84,16 @@ export const clone = function (obj) {
  * @returns {any} L'élément extrait.
  * @throws {TypeError} Si le chemin est invalide.
  */
-export const query = function (obj, chain) {
+export const query = (obj, chain) => {
     if ("" === chain) {
         return obj;
     }
 
-    const re = /^\.(?<prop>\w+)|^\[(?<index>\d+)\]/u;
+    const re = /^\.(?<prop>\w+)|^\[(?<index>\d+)\]/v;
     const sub = {
         obj,
         // Préfixer le chemin avec un point si nécessaire.
-        chain: /^[.[]/u.test(chain) ? chain : "." + chain,
+        chain: /^[.\[]/v.test(chain) ? chain : `.${chain}`,
     };
     while (0 !== sub.chain.length) {
         const result = re.exec(sub.chain);
@@ -118,8 +117,12 @@ export const query = function (obj, chain) {
  * @param {any} child  L'objet enfant.
  * @returns {any} La fusion des deux objets.
  */
-export const merge = function (parent, child) {
-    if (Object !== parent?.constructor || Object !== child?.constructor) {
+export const merge = (parent, child) => {
+    if (
+        child === parent ||
+        Object !== parent?.constructor ||
+        Object !== child?.constructor
+    ) {
         return clone(child);
     }
 
@@ -149,8 +152,8 @@ export const merge = function (parent, child) {
         // surcharges d'éléments.
         if (Array.isArray(overridden[key])) {
             const overelemRegex = new RegExp(
-                `^\\$${key}\\[(?<index>\\d*)\\]$`,
-                "u",
+                String.raw`^\$${key}\[(?<index>\d*)\]$`,
+                "v",
             );
             const overelems = Object.entries(child)
                 .map(([k, v]) => [overelemRegex.exec(k)?.groups?.index, v])
@@ -171,14 +174,14 @@ export const merge = function (parent, child) {
 };
 
 /**
- * Étendre un objet JSON en utilisant les propriétés <code>"$extends"</code>.
+ * Étendre un objet JSON en utilisant la propriété `"$extends"`.
  *
  * @param {Record<string, any>} obj       L'objet qui sera étendu.
  * @param {Options}             [options] Les options.
  * @returns {Promise<Record<string, any>>} Une promesse contenant l'objet
  *                                         étendu.
  */
-export const inherit = async function (obj, options) {
+export const inherit = async (obj, options) => {
     if (undefined === obj.$extends) {
         return obj;
     }
@@ -194,18 +197,18 @@ export const inherit = async function (obj, options) {
  * @param {Options} [options] Les options.
  * @returns {Promise<any>} Une promesse contenant l'objet étendu.
  */
-export const extend = function (obj, options) {
+export const extend = (obj, options) => {
     return walkAsync(obj, (/** @type {any} */ v) => inherit(v, options));
 };
 
 /**
  * Charge un objet JSON depuis une URL.
  *
- * @param {string}  url       L'URL du fichier JSON.
- * @param {Options} [options] Les options.
+ * @param {string|URL} url       L'URL du fichier JSON.
+ * @param {Options}    [options] Les options.
  * @returns {Promise<any>} Une promesse contenant l'objet.
  */
-export const load = async function (url, options) {
+export const load = async (url, options) => {
     let json;
     if (undefined === options?.request) {
         const response = await fetch(url);
@@ -224,6 +227,6 @@ export const load = async function (url, options) {
  * @param {Options} [options] Les options.
  * @returns {Promise<any>} L'objet.
  */
-export const parse = function (text, options) {
+export const parse = (text, options) => {
     return extend(JSON.parse(text), options);
 };

package/types/index.d.ts

@@ -5,6 +5,7 @@ declare namespace _default {
     export { parse };
 }
 export default _default;
+export type Options = import("./jfather.js").Options;
 import { extend } from "./jfather.js";
 import { load } from "./jfather.js";
 import { merge } from "./jfather.js";

package/types/jfather.d.ts

@@ -5,7 +5,7 @@ export function query(obj: Record<string, any>, chain: string): any;
 export function merge(parent: any, child: any): any;
 export function inherit(obj: Record<string, any>, options?: Options): Promise<Record<string, any>>;
 export function extend(obj: any, options?: Options): Promise<any>;
-export function load(url: string, options?: Options): Promise<any>;
+export function load(url: string | URL, options?: Options): Promise<any>;
 export function parse(text: string, options?: Options): Promise<any>;
 /**
  * Les options des fonctions de JFather.
@@ -14,8 +14,7 @@ export type Options = {
     /**
      * La fonction pour récupérer un objet JSON à
      *  distance. Par défaut, l'objet est récupéré avec
-     *  <code>fetch()</code> et
-     *  <code>Response.prototype.json()</code>
+     *  `fetch()` et `Response.json()`.
      */
     request?: Function;
 };