Set package name to @letsflow/jmespath.

Other changes in package.json.
Update README.md
Update compliance tests

Author: jasny

.github/workflows/publish.yml

@@ -37,4 +37,4 @@ jobs:
       - name: ✉️ publish
         run: npm publish --verbose --access public --tag latest
         env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

README.md

@@ -1,31 +1,36 @@
-![Build](https://github.com/jmespath-community/typescript-jmespath/actions/workflows/nodejs.yml/badge.svg?branch=main)
+![Build](https://github.com/letsflow/jmespath/actions/workflows/nodejs.yml/badge.svg?branch=main)
 
-# @jmespath-community/jmespath
+# @letsflow/jmespath
 
-
-@jmespath-community/jmespath is a **TypeScript** implementation of the [JMESPath](https://jmespath.site/) spec.
+@letsflow/jmespath is a **TypeScript** implementation of the [JMESPath](https://jmespath.org/) spec.
 
 JMESPath is a query language for JSON. It will take a JSON document
 as input and transform it into another JSON document
 given a JMESPath expression.
 
+This fork extends the original specs, adding the following functionality;
+
+* [Custom functions](#custom-functions)
+* [Root value access](#root-value-access)
+* [Number literals](#number-literals)
+
 ## INSTALLATION
 
 ```
-npm install @jmespath-community/jmespath
+npm install @letsflow/jmespath
 ```
 
 ## USAGE
 
 ### `search(data: JSONValue, expression: string): JSONValue`
 
 ```javascript
-import { search } from '@jmespath-community/jmespath';
+import { search } from '@letsflow/jmespath';
 
 search(
-  {foo: {bar: {baz: [0, 1, 2, 3, 4]}}},
+  { foo: { bar: { baz: [0, 1, 2, 3, 4] } } },
   "foo.bar.baz[2]"
-  );
+);
 
 // OUTPUTS: 2
 ```
@@ -39,48 +44,48 @@ The JMESPath language can do *a lot* more than select an element
 from a list.  Here are a few more examples:
 
 ```javascript
-import { search } from '@jmespath-community/jmespath';
+import { search } from '@letsflow/jmespath';
 
-/* --- EXAMPLE 1 --- */
-
-let JSON_DOCUMENT = {
+const document = {
   foo: {
     bar: {
       baz: [0, 1, 2, 3, 4]
     }
   }
 };
 
-search(JSON_DOCUMENT, "foo.bar");
+search(document, "foo.bar");
 // OUTPUTS: { baz: [ 0, 1, 2, 3, 4 ] }
+```
 
+```javascript
+import { search } from '@letsflow/jmespath';
 
-/* --- EXAMPLE 2 --- */
-
-JSON_DOCUMENT = {
+const document = {
   "foo": [
-    {"first": "a", "last": "b"},
-    {"first": "c", "last": "d"}
+    { "first": "a", "last": "b" },
+    { "first": "c", "last": "d" }
   ]
 };
 
-search(JSON_DOCUMENT, "foo[*].first")
+search(document, "foo[*].first")
 // OUTPUTS: [ 'a', 'c' ]
+```
 
+```javascript
+import { search } from '@letsflow/jmespath';
 
-/* --- EXAMPLE 3 --- */
-
-JSON_DOCUMENT = {
+const document = {
   "foo": [
-    {"age": 20},
-    {"age": 25},
-    {"age": 30},
-    {"age": 35},
-    {"age": 40}
+    { "age": 20 },
+    { "age": 25 },
+    { "age": 30 },
+    { "age": 35 },
+    { "age": 40 }
   ]
 }
 
-search(JSON_DOCUMENT, "foo[?age > `30`]");
+search(document, "foo[?age > `30`]");
 // OUTPUTS: [ { age: 35 }, { age: 40 } ]
 ```
 
@@ -95,82 +100,91 @@ import { compile, TreeInterpreter } from '@jmespath-community/jmespath';
 
 const ast = compile('foo.bar');
 
-TreeInterpreter.search(ast, {foo: {bar: 'BAZ'}})
+TreeInterpreter.search(ast, { foo: { bar: 'BAZ' } })
 // RETURNS: "BAZ"
-
 ```
 
----
 ## EXTENSIONS TO ORIGINAL SPEC
 
-1. ### Register you own custom functions
+### Custom functions
 
-    #### `registerFunction(functionName: string, customFunction: RuntimeFunction, signature: InputSignature[]): void`
+#### `registerFunction(functionName: string, customFunction: RuntimeFunction, signature: InputSignature[]): void`
 
-    Extend the list of built in JMESpath expressions with your own functions.
+Extend the list of built-in JMESpath expressions with your own functions.
 
-    ```javascript
-      import {search, registerFunction, TYPE_NUMBER} from '@jmespath-community/jmespath'
-
-
-      search({ foo: 60, bar: 10 }, 'divide(foo, bar)')
-      // THROWS ERROR: Error: Unknown function: divide()
+```javascript
+  import {search, registerFunction, TYPE_NUMBER} from '@letsflow/jmespath'
+
+  search({ foo: 60, bar: 10 }, 'divide(foo, bar)')
+  // THROWS ERROR: Error: Unknown function: divide()
+
+  registerFunction(
+    'divide', // FUNCTION NAME
+    (resolvedArgs) => {   // CUSTOM FUNCTION
+      const [dividend, divisor] = resolvedArgs;
+      return dividend / divisor;
+    },
+    [{ types: [TYPE_NUMBER] }, { types: [TYPE_NUMBER] }] //SIGNATURE
+  );
 
-      registerFunction(
-        'divide', // FUNCTION NAME
-        (resolvedArgs) => {   // CUSTOM FUNCTION
-          const [dividend, divisor] = resolvedArgs;
-          return dividend / divisor;
-        },
-        [{ types: [TYPE_NUMBER] }, { types: [TYPE_NUMBER] }] //SIGNATURE
-      );
+  search({ foo: 60, bar: 10 }, 'divide(foo, bar)');
+  // OUTPUTS: 6
+```
 
-      search({ foo: 60,bar: 10 }, 'divide(foo, bar)');
-      // OUTPUTS: 6
+Optional arguments are supported by setting `{..., optional: true}` in argument signatures
 
-    ```
+```javascript
+  registerFunction(
+    'divide',
+    (resolvedArgs) => {
+      const [dividend, divisor] = resolvedArgs;
+      return dividend / divisor ?? 1; //OPTIONAL DIVISOR THAT DEFAULTS TO 1
+    },
+    [{ types: [TYPE_NUMBER] }, { types: [TYPE_NUMBER], optional: true }] //SIGNATURE
+  );
 
-    Optional arguments are supported by setting `{..., optional: true}` in argument signatures
+  search({ foo: 60, bar: 10 }, 'divide(foo)');
+  // OUTPUTS: 60
+```
 
+### Root value access
 
-    ```javascript
+Use `$` to access the document root.
 
-      registerFunction(
-        'divide',
-        (resolvedArgs) => {
-          const [dividend, divisor] = resolvedArgs;
-          return dividend / divisor ?? 1; //OPTIONAL DIVISOR THAT DEFAULTS TO 1
-        },
-        [{ types: [TYPE_NUMBER] }, { types: [TYPE_NUMBER], optional: true }] //SIGNATURE
-      );
+```javascript
+search({foo: { bar: 999 }, baz: [1, 2, 3]}, '$.baz[*].[@, $.foo.bar]')
 
-      search({ foo: 60, bar: 10 }, 'divide(foo)');
-      // OUTPUTS: 60
+// OUTPUTS:
+// [ [ 1, 999 ], [ 2, 999 ], [ 3, 999 ] ]
+```
 
-    ```
+### Number literals
 
-2. ### Root value access with `$` symbol
+Numbers in the root scope are treated as number literals. This means that you don't
+need to quote numbers with backticks.
 
 ```javascript
+search([{"bar": 1}, {"bar": 10}]}, '[?bar==10]')
 
-search({foo: {bar: 999}, baz: [1, 2, 3]}, '$.baz[*].[@, $.foo.bar]')
+// OUTPUTS;
+// [{"bar": 10}]
+```
+
+You can also use numbers in arithmetic operations
 
-// OUTPUTS:
-// [ [ 1, 999 ], [ 2, 999 ], [ 3, 999 ] ]
 ```
+search({}, '16 + 26'); // 42
 
+// With the original specs we'd need to do
+search({}, '`16` + `26`');
+```
 
 ## More Resources
 
-The example above only show a small amount of what
+The example above only shows a small amount of what
 a JMESPath expression can do. If you want to take a
 tour of the language, the *best* place to go is the
-[JMESPath Tutorial](http://jmespath.site/main#tutorial).
-
-One of the best things about JMESPath is that it is
-implemented in many different programming languages including
-python, ruby, php, lua, etc.  To see a complete list of libraries,
-check out the [JMESPath libraries page](http://jmespath.site/main#libraries).
+[JMESPath Tutorial](https://jmespath.org/tutorial.html).
 
-And finally, the full JMESPath specification can be found
-on the [JMESPath site](https://jmespath.site/main/#specification).
+The full JMESPath specification can be found
+on the [JMESPath site](https://jmespath.org/specification.html).

package-lock.json

@@ -1,22 +1,32 @@
 {
-  "name": "@jmespath-community/jmespath",
-  "description": "Typescript implementation of the JMESPath Community specification",
-  "version": "1.1.4",
-  "author": {
-    "name": "JMESPath Community",
-    "email": "[email protected]",
-    "url": "https://jmespath.site"
+  "name": "@letsflow/jmespath",
+  "description": "Typescript implementation of the JMESPath Community specification with additional functionality for LetsFlow",
+  "version": "1.1.4-jasny.3",
+  "publishConfig": {
+    "access": "public"
   },
+  "homepage": "https://letsflow.io/jmespath",
+  "contributors": [
+    {
+      "name": "Arnold Daniels",
+      "email": "[email protected]",
+      "url": "https://jasny.net"
+    },
+    {
+      "name": "JMESPath Community",
+      "email": "[email protected]",
+      "url": "https://jmespath.site"
+    }
+  ],
   "main": "dist/jmespath.umd.js",
   "module": "dist/jmespath.esm.js",
   "typings": "dist/types/index.d.ts",
   "types": "dist/types/index.d.ts",
   "files": [
     "dist/"
   ],
-  "homepage": "https://github.com/nanoporetech/jmespath-ts#readme",
   "bugs": {
-    "url": "https://github.com/nanoporetech/jmespath-ts/issues",
+    "url": "https://github.com/letsflow/jmespath/issues",
     "mail": ""
   },
   "keywords": [
@@ -27,10 +37,9 @@
     "jq",
     "xpath"
   ],
-  "contributors": [],
   "repository": {
     "type": "git",
-    "url": "git://github.com/jmespath-community/typescript-jmespath"
+    "url": "git://github.com/letsflow/jmespath"
   },
   "license": "MPL-2.0",
   "engines": {
@@ -77,5 +86,5 @@
     "ts-node": "^10.9.1",
     "typescript": "^4.3.2",
     "vitest": "^2.1.8"
-  }
+  }  
 }