@basemaps/lambda-tiler 6.38.0 → 6.39.0

package/dist/node_modules/.package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.38.0",
+  "version": "6.39.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
@@ -229,9 +229,9 @@
       "integrity": "sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg=="
     },
     "node_modules/node-abi": {
-      "version": "3.30.0",
-      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.30.0.tgz",
-      "integrity": "sha512-qWO5l3SCqbwQavymOmtTVuCWZE23++S+rxyoHjXqUmPyzRcaoI4lA2gO55/drddGnedAyjA7sk76SfQ5lfUMnw==",
+      "version": "3.31.0",
+      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.31.0.tgz",
+      "integrity": "sha512-eSKV6s+APenqVh8ubJyiu/YhZgxQpGP66ntzUb3lY1xB9ukSRaGnx0AIxI+IM+1+IVYC1oWobgG5L3Lt9ARykQ==",
       "dependencies": {
         "semver": "^7.3.5"
       },
@@ -240,9 +240,9 @@
       }
     },
     "node_modules/node-addon-api": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.0.0.tgz",
-      "integrity": "sha512-CvkDw2OEnme7ybCykJpVcKH+uAOLV2qLqiyla128dN9TkEWfrYmxG6C2boDe5KcNQqZF3orkqzGgOMvZ/JNekA=="
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz",
+      "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA=="
     },
     "node_modules/once": {
       "version": "1.4.0",

package/dist/node_modules/node-abi/.circleci/config.yml

@@ -16,15 +16,9 @@ steps-test: &steps-test
     - run: yarn test
 
 version: 2.1
+orbs:
+  cfa: continuousauth/npm@1.0.2
 jobs:
-  test-linux-10:
-    docker:
-      - image: circleci/node:10
-    <<: *steps-test
-  test-linux-12:
-    docker:
-      - image: circleci/node:12
-    <<: *steps-test
   test-linux-14:
     docker:
       - image: circleci/node:14
@@ -34,30 +28,18 @@ jobs:
       - image: circleci/node:16
     <<: *steps-test
 
-  release:
-    docker:
-      - image: circleci/node:14.15
-    steps:
-      - checkout
-      - *step-restore-cache
-      - run: yarn --frozen-lockfile
-      - run: npx semantic-release@17.4.5
 workflows:
-  version: 2
   test_and_release:
     # Run test jobs first, release only when all the test jobs are successful
     jobs:
-      - test-linux-10
-      - test-linux-12
       - test-linux-14
       - test-linux-16
-      - release:
+      - cfa/release:
           requires:
-            - test-linux-10
-            - test-linux-12
             - test-linux-14
             - test-linux-16
           filters:
             branches:
               only:
-                - main
+                - main
+          context: cfa-release

package/dist/node_modules/node-abi/CONTRIBUTING.md

@@ -4,7 +4,7 @@
 
 ## Commit Message Guidelines
 
-This module uses [`semantic-release`](https://github.com/semantic-release/semantic-release) to automatically release new versions via Travis.
+This module uses [`semantic-release`](https://github.com/semantic-release/semantic-release) to automatically release new versions via [Continuous Auth](https://continuousauth.dev/).
 Therefor we have very precise rules over how our git commit messages can be formatted.
 
 Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special

package/dist/node_modules/node-abi/abi_registry.json

@@ -227,5 +227,12 @@
     "lts": false,
     "runtime": "electron",
     "target": "22.0.0-alpha.1"
+  },
+  {
+    "abi": "113",
+    "future": true,
+    "lts": false,
+    "runtime": "electron",
+    "target": "23.0.0-alpha.1"
   }
 ]

package/dist/node_modules/node-abi/package.json

@@ -1,10 +1,9 @@
 {
   "name": "node-abi",
-  "version": "3.30.0",
+  "version": "3.31.0",
   "description": "Get the Node ABI for a given target and runtime, and vice versa.",
   "main": "index.js",
   "scripts": {
-    "semantic-release": "semantic-release",
     "test": "tape test/index.js",
     "update-abi-registry": "node --unhandled-rejections=strict scripts/update-abi-registry.js"
   },
@@ -26,7 +25,7 @@
   },
   "homepage": "https://github.com/lgeiger/node-abi#readme",
   "devDependencies": {
-    "@continuous-auth/semantic-release-npm": "^2.0.0",
+    "@continuous-auth/semantic-release-npm": "^3.0.0",
     "got": "^11.8.2",
     "tape": "^5.3.1"
   },

package/dist/node_modules/node-addon-api/README.md

@@ -16,15 +16,15 @@ provided by Node.js when using C++. It provides a C++ object model
 and exception handling semantics with low overhead.
 
 There are three options for implementing addons: Node-API, nan, or direct
-use of internal V8, libuv and Node.js libraries. Unless there is a need for
-direct access to functionality which is not exposed by Node-API as outlined
+use of internal V8, libuv, and Node.js libraries. Unless there is a need for
+direct access to functionality that is not exposed by Node-API as outlined
 in [C/C++ addons](https://nodejs.org/dist/latest/docs/api/addons.html)
 in Node.js core, use Node-API. Refer to
 [C/C++ addons with Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
 for more information on Node-API.
 
 Node-API is an ABI stable C interface provided by Node.js for building native
-addons. It is independent from the underlying JavaScript runtime (e.g. V8 or ChakraCore)
+addons. It is independent of the underlying JavaScript runtime (e.g. V8 or ChakraCore)
 and is maintained as part of Node.js itself. It is intended to insulate
 native addons from changes in the underlying JavaScript engine and allow
 modules compiled for one version to run on later versions of Node.js without
@@ -46,7 +46,7 @@ provides an [ABI stability guide][] containing a detailed explanation of ABI
 stability in general, and the Node-API ABI stability guarantee in particular.
 
 As new APIs are added to Node-API, node-addon-api must be updated to provide
-wrappers for those new APIs. For this reason node-addon-api provides
+wrappers for those new APIs. For this reason, node-addon-api provides
 methods that allow callers to obtain the underlying Node-API handles so
 direct calls to Node-API and the use of the objects/methods provided by
 node-addon-api can be used together. For example, in order to be able
@@ -56,7 +56,7 @@ APIs exposed by node-addon-api are generally used to create and
 manipulate JavaScript values. Concepts and operations generally map
 to ideas specified in the **ECMA262 Language Specification**.
 
-The [Node-API Resource](https://nodejs.github.io/node-addon-examples/) offers an
+The [Node-API Resource](https://nodejs.github.io/node-addon-examples/) offers an
 excellent orientation and tips for developers just getting started with Node-API
 and node-addon-api.
 
@@ -70,7 +70,7 @@ and node-addon-api.
 - **[Contributors](#contributors)**
 - **[License](#license)**
 
-## **Current version: 5.0.0**
+## **Current version: 5.1.0**
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
 
@@ -187,6 +187,28 @@ npm test --NAPI_VERSION=X
 
 where X is the version of Node-API you want to target.
 
+To run a specific unit test, filter conditions are available
+
+**Example:**
+  compile and run only tests on objectwrap.cc and objectwrap.js
+  ```
+    npm run unit --filter=objectwrap
+  ```
+
+Multiple unit tests cane be selected with wildcards
+
+**Example:**
+compile and run all test files ending with "reference" -> function_reference.cc, object_reference.cc, reference.cc
+ ```
+    npm run unit --filter=*reference
+ ```
+
+Multiple filter conditions can be joined to broaden the test selection
+
+**Example:**
+ compile and run all tests under folders threadsafe_function and typed_threadsafe_function and also the objectwrap.cc file
+    npm run unit --filter='*function objectwrap'
+
 ### **Debug**
 
 To run the **node-addon-api** tests with `--debug` option:
@@ -195,7 +217,7 @@ To run the **node-addon-api** tests with `--debug` option:
 npm run-script dev
 ```
 
-If you want faster build, you might use the following option:
+If you want a faster build, you might use the following option:
 
 ```
 npm run-script dev:incremental
@@ -223,7 +245,7 @@ See [benchmark/README.md](benchmark/README.md) for more details about running an
 
 As node-addon-api's core mission is to expose the plain C Node-API as C++
 wrappers, tools that facilitate n-api/node-addon-api providing more
-convenient patterns on developing a Node.js add-ons with n-api/node-addon-api
+convenient patterns for developing a Node.js add-on with n-api/node-addon-api
 can be published to NPM as standalone packages. It is also recommended to tag
 such packages with `node-addon-api` to provide more visibility to the community.
 
@@ -269,19 +291,21 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for more details on our philosophy around
 | ------------------- | ----------------------------------------------------- |
 | Anna Henningsen     | [addaleax](https://github.com/addaleax)               |
 | Chengzhong Wu       | [legendecas](https://github.com/legendecas)           |
-| Gabriel Schulhof    | [gabrielschulhof](https://github.com/gabrielschulhof) |
-| Jim Schlight        | [jschlight](https://github.com/jschlight)             |
+| Jack Xia            | [JckXia](https://github.com/JckXia)                   |
+| Kevin Eady          | [KevinEady](https://github.com/KevinEady)             |
 | Michael Dawson      | [mhdawson](https://github.com/mhdawson)               |
-| Kevin Eady          | [KevinEady](https://github.com/KevinEady)
 | Nicola Del Gobbo    | [NickNaso](https://github.com/NickNaso)               |
+| Vladimir Morozov    | [vmoroz](https://github.com/vmoroz)                   |
 
 ### Emeritus
 | Name                | GitHub Link                                           |
 | ------------------- | ----------------------------------------------------- |
 | Arunesh Chandra     | [aruneshchandra](https://github.com/aruneshchandra)   |
 | Benjamin Byholm     | [kkoopa](https://github.com/kkoopa)                   |
-| Jason Ginchereau    | [jasongin](https://github.com/jasongin)               |
+| Gabriel Schulhof    | [gabrielschulhof](https://github.com/gabrielschulhof) |
 | Hitesh Kanwathirtha | [digitalinfinity](https://github.com/digitalinfinity) |
+| Jason Ginchereau    | [jasongin](https://github.com/jasongin)               |
+| Jim Schlight        | [jschlight](https://github.com/jschlight)             |
 | Sampson Gao         | [sampsongao](https://github.com/sampsongao)           |
 | Taylor Woll         | [boingoing](https://github.com/boingoing)             |
 

package/dist/node_modules/node-addon-api/index.js

@@ -1,11 +1,11 @@
 const path = require('path');
 
-const include_dir = path.relative('.', __dirname);
+const includeDir = path.relative('.', __dirname);
 
 module.exports = {
   include: `"${__dirname}"`, // deprecated, can be removed as part of 4.0.0
-  include_dir,
-  gyp: path.join(include_dir, 'node_api.gyp:nothing'),
+  include_dir: includeDir,
+  gyp: path.join(includeDir, 'node_api.gyp:nothing'),
   isNodeApiBuiltin: true,
   needsFlag: false
 };

package/dist/node_modules/node-addon-api/napi-inl.deprecated.h

@@ -6,187 +6,181 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename Getter>
-inline PropertyDescriptor
-PropertyDescriptor::Accessor(const char* utf8name,
-                             Getter getter,
-                             napi_property_attributes attributes,
-                             void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const char* utf8name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using CbData = details::CallbackData<Getter, Napi::Value>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, nullptr });
-
-  return PropertyDescriptor({
-    utf8name,
-    nullptr,
-    nullptr,
-    CbData::Wrapper,
-    nullptr,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({getter, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Getter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(const std::string& utf8name,
-                                                       Getter getter,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const std::string& utf8name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* data) {
   return Accessor(utf8name.c_str(), getter, attributes, data);
 }
 
 template <typename Getter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(napi_value name,
-                                                       Getter getter,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    napi_value name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using CbData = details::CallbackData<Getter, Napi::Value>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, nullptr });
-
-  return PropertyDescriptor({
-    nullptr,
-    name,
-    nullptr,
-    CbData::Wrapper,
-    nullptr,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({getter, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Getter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(Name name,
-                                                       Getter getter,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    Name name, Getter getter, napi_property_attributes attributes, void* data) {
   napi_value nameValue = name;
   return PropertyDescriptor::Accessor(nameValue, getter, attributes, data);
 }
 
 template <typename Getter, typename Setter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(const char* utf8name,
-                                                       Getter getter,
-                                                       Setter setter,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const char* utf8name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using CbData = details::AccessorCallbackData<Getter, Setter>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, setter, nullptr });
-
-  return PropertyDescriptor({
-    utf8name,
-    nullptr,
-    nullptr,
-    CbData::GetterWrapper,
-    CbData::SetterWrapper,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({getter, setter, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             nullptr,
+                             CbData::GetterWrapper,
+                             CbData::SetterWrapper,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Getter, typename Setter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(const std::string& utf8name,
-                                                       Getter getter,
-                                                       Setter setter,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const std::string& utf8name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* data) {
   return Accessor(utf8name.c_str(), getter, setter, attributes, data);
 }
 
 template <typename Getter, typename Setter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(napi_value name,
-                                                       Getter getter,
-                                                       Setter setter,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    napi_value name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using CbData = details::AccessorCallbackData<Getter, Setter>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, setter, nullptr });
-
-  return PropertyDescriptor({
-    nullptr,
-    name,
-    nullptr,
-    CbData::GetterWrapper,
-    CbData::SetterWrapper,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({getter, setter, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             nullptr,
+                             CbData::GetterWrapper,
+                             CbData::SetterWrapper,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Getter, typename Setter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(Name name,
-                                                       Getter getter,
-                                                       Setter setter,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    Name name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* data) {
   napi_value nameValue = name;
-  return PropertyDescriptor::Accessor(nameValue, getter, setter, attributes, data);
+  return PropertyDescriptor::Accessor(
+      nameValue, getter, setter, attributes, data);
 }
 
 template <typename Callable>
-inline PropertyDescriptor PropertyDescriptor::Function(const char* utf8name,
-                                                       Callable cb,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Function(
+    const char* utf8name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
   using CbData = details::CallbackData<Callable, ReturnType>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ cb, nullptr });
-
-  return PropertyDescriptor({
-    utf8name,
-    nullptr,
-    CbData::Wrapper,
-    nullptr,
-    nullptr,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({cb, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Callable>
-inline PropertyDescriptor PropertyDescriptor::Function(const std::string& utf8name,
-                                                       Callable cb,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Function(
+    const std::string& utf8name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* data) {
   return Function(utf8name.c_str(), cb, attributes, data);
 }
 
 template <typename Callable>
-inline PropertyDescriptor PropertyDescriptor::Function(napi_value name,
-                                                       Callable cb,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Function(
+    napi_value name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
   using CbData = details::CallbackData<Callable, ReturnType>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ cb, nullptr });
-
-  return PropertyDescriptor({
-    nullptr,
-    name,
-    CbData::Wrapper,
-    nullptr,
-    nullptr,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({cb, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Callable>
-inline PropertyDescriptor PropertyDescriptor::Function(Name name,
-                                                       Callable cb,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Function(
+    Name name, Callable cb, napi_property_attributes attributes, void* data) {
   napi_value nameValue = name;
   return PropertyDescriptor::Function(nameValue, cb, attributes, data);
 }
 
-#endif // !SRC_NAPI_INL_DEPRECATED_H_
+#endif  // !SRC_NAPI_INL_DEPRECATED_H_