@zuplo/cli 7.0.1 → 7.1.0

package/node_modules/@zuplo/editor/node_modules/strip-json-comments/index.js

@@ -0,0 +1,77 @@
+'use strict';
+const singleComment = Symbol('singleComment');
+const multiComment = Symbol('multiComment');
+const stripWithoutWhitespace = () => '';
+const stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/\S/g, ' ');
+
+const isEscaped = (jsonString, quotePosition) => {
+	let index = quotePosition - 1;
+	let backslashCount = 0;
+
+	while (jsonString[index] === '\\') {
+		index -= 1;
+		backslashCount += 1;
+	}
+
+	return Boolean(backslashCount % 2);
+};
+
+module.exports = (jsonString, options = {}) => {
+	if (typeof jsonString !== 'string') {
+		throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+	}
+
+	const strip = options.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+
+	let insideString = false;
+	let insideComment = false;
+	let offset = 0;
+	let result = '';
+
+	for (let i = 0; i < jsonString.length; i++) {
+		const currentCharacter = jsonString[i];
+		const nextCharacter = jsonString[i + 1];
+
+		if (!insideComment && currentCharacter === '"') {
+			const escaped = isEscaped(jsonString, i);
+			if (!escaped) {
+				insideString = !insideString;
+			}
+		}
+
+		if (insideString) {
+			continue;
+		}
+
+		if (!insideComment && currentCharacter + nextCharacter === '//') {
+			result += jsonString.slice(offset, i);
+			offset = i;
+			insideComment = singleComment;
+			i++;
+		} else if (insideComment === singleComment && currentCharacter + nextCharacter === '\r\n') {
+			i++;
+			insideComment = false;
+			result += strip(jsonString, offset, i);
+			offset = i;
+			continue;
+		} else if (insideComment === singleComment && currentCharacter === '\n') {
+			insideComment = false;
+			result += strip(jsonString, offset, i);
+			offset = i;
+		} else if (!insideComment && currentCharacter + nextCharacter === '/*') {
+			result += jsonString.slice(offset, i);
+			offset = i;
+			insideComment = multiComment;
+			i++;
+			continue;
+		} else if (insideComment === multiComment && currentCharacter + nextCharacter === '*/') {
+			i++;
+			insideComment = false;
+			result += strip(jsonString, offset, i + 1);
+			offset = i + 1;
+			continue;
+		}
+	}
+
+	return result + (insideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+};

package/node_modules/@zuplo/editor/node_modules/strip-json-comments/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/@zuplo/editor/node_modules/strip-json-comments/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "strip-json-comments",
+	"version": "3.1.1",
+	"description": "Strip comments from JSON. Lets you use comments in your JSON files!",
+	"license": "MIT",
+	"repository": "sindresorhus/strip-json-comments",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd",
+		"bench": "matcha benchmark.js"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"json",
+		"strip",
+		"comments",
+		"remove",
+		"delete",
+		"trim",
+		"multiline",
+		"parse",
+		"config",
+		"configuration",
+		"settings",
+		"util",
+		"env",
+		"environment",
+		"jsonc"
+	],
+	"devDependencies": {
+		"ava": "^1.4.1",
+		"matcha": "^0.7.0",
+		"tsd": "^0.7.2",
+		"xo": "^0.24.0"
+	}
+}

package/node_modules/@zuplo/editor/node_modules/strip-json-comments/readme.md

@@ -0,0 +1,78 @@
+# strip-json-comments [![Build Status](https://travis-ci.com/sindresorhus/strip-json-comments.svg?branch=master)](https://travis-ci.com/github/sindresorhus/strip-json-comments)
+
+> Strip comments from JSON. Lets you use comments in your JSON files!
+
+This is now possible:
+
+```js
+{
+	// Rainbows
+	"unicorn": /* ❤ */ "cake"
+}
+```
+
+It will replace single-line comments `//` and multi-line comments `/**/` with whitespace. This allows JSON error positions to remain as close as possible to the original source.
+
+Also available as a [Gulp](https://github.com/sindresorhus/gulp-strip-json-comments)/[Grunt](https://github.com/sindresorhus/grunt-strip-json-comments)/[Broccoli](https://github.com/sindresorhus/broccoli-strip-json-comments) plugin.
+
+## Install
+
+```
+$ npm install strip-json-comments
+```
+
+## Usage
+
+```js
+const json = `{
+	// Rainbows
+	"unicorn": /* ❤ */ "cake"
+}`;
+
+JSON.parse(stripJsonComments(json));
+//=> {unicorn: 'cake'}
+```
+
+## API
+
+### stripJsonComments(jsonString, options?)
+
+#### jsonString
+
+Type: `string`
+
+Accepts a string with JSON and returns a string without comments.
+
+#### options
+
+Type: `object`
+
+##### whitespace
+
+Type: `boolean`\
+Default: `true`
+
+Replace comments with whitespace instead of stripping them entirely.
+
+## Benchmark
+
+```
+$ npm run bench
+```
+
+## Related
+
+- [strip-json-comments-cli](https://github.com/sindresorhus/strip-json-comments-cli) - CLI for this module
+- [strip-css-comments](https://github.com/sindresorhus/strip-css-comments) - Strip comments from CSS
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-strip-json-comments?utm_source=npm-strip-json-comments&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>

package/node_modules/@zuplo/editor/node_modules/thread-stream/.claude/settings.local.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx tap:*)",
+      "Bash(node:*)",
+      "Bash(for i in 1 2 3 4 5)",
+      "Bash(do)",
+      "Bash(echo:*)",
+      "Bash(done)",
+      "Bash(npm test:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/node_modules/@zuplo/editor/node_modules/thread-stream/.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    open-pull-requests-limit: 10
+
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10

package/node_modules/{pino → @zuplo/editor/node_modules/thread-stream}/.github/workflows/ci.yml

@@ -2,16 +2,13 @@ name: CI
 
 on:
   push:
-    branches:
-      - main
-      - 'v*'
     paths-ignore:
-      - 'docs/**'
-      - '*.md'
+        - 'docs/**'
+        - '*.md'
   pull_request:
     paths-ignore:
-      - 'docs/**'
-      - '*.md'
+        - 'docs/**'
+        - '*.md'
 
 # This allows a subsequently queued workflow run to interrupt previous runs
 concurrency:
@@ -27,7 +24,7 @@ jobs:
       contents: read
     steps:
       - name: Check out repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           persist-credentials: false
 
@@ -35,22 +32,21 @@ jobs:
         uses: actions/dependency-review-action@v4
 
   test:
-    name: ${{ matrix.node-version }} ${{ matrix.os }}
+    name: Test
     runs-on: ${{ matrix.os }}
     permissions:
       contents: read
     strategy:
-      fail-fast: false
       matrix:
-        os: [macOS-latest, windows-latest, ubuntu-latest]
         node-version: [18, 20, 22]
+        os: [macos-latest, ubuntu-latest, windows-latest]
         exclude:
           - os: windows-latest
             node-version: 22
 
     steps:
       - name: Check out repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           persist-credentials: false
 
@@ -63,13 +59,24 @@ jobs:
         run: npm i --ignore-scripts
 
       - name: Run tests
-        run: npm run test-ci
+        run: npm run test:ci
 
-      - name: Run smoke test
-        if: >
-          matrix.os != 'windows-latest' &&
-          matrix.node-version > 14
-        run: npm run test:smoke
+      - name: Coveralls Parallel
+        uses: coverallsapp/github-action@v2.3.0
+        with:
+          github-token: ${{ secrets.github_token }}
+          parallel: true
+          flag-name: run-${{ matrix.node-version }}-${{ matrix.os }}
+
+  coverage:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Coveralls Finished
+        uses: coverallsapp/github-action@v2.3.0
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          parallel-finished: true
 
   automerge:
     name: Automerge Dependabot PRs
@@ -85,4 +92,3 @@ jobs:
       - uses: fastify/github-action-merge-dependabot@v3
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
-          exclude: 'sonic-boom,pino-std-serializers,quick-format-unescaped,fast-redact'

package/node_modules/@zuplo/editor/node_modules/thread-stream/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm test

package/node_modules/@zuplo/editor/node_modules/{process-warning → thread-stream}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-present The Fastify team <https://github.com/fastify/fastify#team>
+Copyright (c) 2021 Matteo Collina
 
 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/node_modules/@zuplo/editor/node_modules/thread-stream/README.md

@@ -0,0 +1,136 @@
+# thread-stream
+[![npm version](https://img.shields.io/npm/v/thread-stream)](https://www.npmjs.com/package/thread-stream)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/pinojs/thread-stream/ci.yml?branch=main)](https://github.com/pinojs/thread-stream/actions)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
+
+A streaming way to send data to a Node.js Worker Thread.
+
+## install
+
+```sh
+npm i thread-stream
+```
+
+## Usage
+
+```js
+'use strict'
+
+const ThreadStream = require('thread-stream')
+const { join } = require('path')
+
+const stream = new ThreadStream({
+  filename: join(__dirname, 'worker.js'),
+  workerData: { dest },
+  workerOpts: {}, // Other options to be passed to Worker
+  sync: false, // default
+})
+
+stream.write('hello')
+
+// Asynchronous flushing
+stream.flush(function () {
+  stream.write(' ')
+  stream.write('world')
+
+  // Synchronous flushing
+  stream.flushSync()
+  stream.end()
+})
+```
+
+In `worker.js`:
+
+```js
+'use strict'
+
+const fs = require('fs')
+const { once } = require('events')
+
+async function run (opts) {
+  const stream = fs.createWriteStream(opts.dest)
+  await once(stream, 'open')
+  return stream
+}
+
+module.exports = run
+```
+
+Make sure that the stream emits `'close'` when the stream completes.
+This can usually be achieved by passing the [`autoDestroy: true`](https://nodejs.org/api/stream.html#stream_new_stream_writable_options)
+flag your stream classes.
+
+The underlining worker is automatically closed if the stream is garbage collected.
+
+
+### External modules
+
+You may use this module within compatible external modules, that exports the `worker.js` interface.
+
+```js
+const ThreadStream = require('thread-stream')
+
+const modulePath = require.resolve('pino-elasticsearch')
+
+const stream = new ThreadStream({
+  filename: modulePath,
+  workerData: { node: 'http://localhost:9200' }
+})
+
+stream.write('log to elasticsearch!')
+stream.flushSync()
+stream.end()
+```
+
+This module works with `yarn` in PnP (plug'n play) mode too!
+
+### Emit events
+
+You can emit events on the ThreadStream from your worker using [`worker.parentPort.postMessage()`](https://nodejs.org/api/worker_threads.html#workerparentport).
+Messages that do not carry a thread-stream protocol `code` are ignored.
+For custom events, the message (JSON object) must have the following data structure:
+
+```js
+parentPort.postMessage({
+  code: 'EVENT',
+  name: 'eventName',
+  args: ['list', 'of', 'args', 123, new Error('Boom')]
+})
+```
+
+On your ThreadStream, you can add a listener function for this event name:
+
+```js
+const stream = new ThreadStream({
+  filename: join(__dirname, 'worker.js'),
+  workerData: {},
+})
+stream.on('eventName', function (a, b, c, n, err) {
+  console.log('received:', a, b, c, n, err) // received: list of args 123 Error: Boom
+})
+```
+
+### Post Messages
+
+You can post messages to the worker by emitting a `message` event on the ThreadStream.
+
+```js
+const stream = new ThreadStream({
+  filename: join(__dirname, 'worker.js'),
+  workerData: {},
+})
+stream.emit('message', message)
+```
+
+On your worker, you can listen for this message using [`worker.parentPort.on('message', cb)`](https://nodejs.org/api/worker_threads.html#event-message).
+
+```js
+const { parentPort } = require('worker_threads')
+parentPort.on('message', function (message) {
+  console.log('received:', message)
+})
+```
+
+## License
+
+MIT

package/node_modules/@zuplo/editor/node_modules/thread-stream/bench.js

@@ -0,0 +1,85 @@
+'use strict'
+
+const bench = require('fastbench')
+const SonicBoom = require('sonic-boom')
+const ThreadStream = require('.')
+const Console = require('console').Console
+const fs = require('fs')
+const { join } = require('path')
+
+const core = fs.createWriteStream('/dev/null')
+const fd = fs.openSync('/dev/null', 'w')
+const sonic = new SonicBoom({ fd })
+const sonicSync = new SonicBoom({ fd, sync: true })
+const out = fs.createWriteStream('/dev/null')
+const dummyConsole = new Console(out)
+const threadStreamSync = new ThreadStream({
+  filename: join(__dirname, 'test', 'to-file.js'),
+  workerData: { dest: '/dev/null' },
+  bufferSize: 4 * 1024 * 1024,
+  sync: true
+})
+const threadStreamAsync = new ThreadStream({
+  filename: join(__dirname, 'test', 'to-file.js'),
+  workerData: { dest: '/dev/null' },
+  bufferSize: 4 * 1024 * 1024,
+  sync: false
+})
+
+const MAX = 10000
+
+let str = ''
+
+for (let i = 0; i < 100; i++) {
+  str += 'hello'
+}
+
+setTimeout(doBench, 100)
+
+const run = bench([
+  function benchThreadStreamSync (cb) {
+    for (let i = 0; i < MAX; i++) {
+      threadStreamSync.write(str)
+    }
+    setImmediate(cb)
+  },
+  function benchThreadStreamAsync (cb) {
+    threadStreamAsync.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      threadStreamAsync.write(str)
+    }
+  },
+  function benchSonic (cb) {
+    sonic.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      sonic.write(str)
+    }
+  },
+  function benchSonicSync (cb) {
+    sonicSync.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      sonicSync.write(str)
+    }
+  },
+  function benchCore (cb) {
+    core.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      core.write(str)
+    }
+  },
+  function benchConsole (cb) {
+    for (let i = 0; i < MAX; i++) {
+      dummyConsole.log(str)
+    }
+    setImmediate(cb)
+  }
+], 1000)
+
+function doBench () {
+  run(function () {
+    run(function () {
+      // TODO figure out why it does not shut down
+      process.exit(0)
+    })
+  })
+}

package/node_modules/@zuplo/editor/node_modules/thread-stream/index.d.ts

@@ -0,0 +1,92 @@
+import { EventEmitter } from 'events'
+import * as workerThreads from 'worker_threads'
+
+interface ThreadStreamOptions {
+  /**
+   * The size (in bytes) of the buffer.
+   * Must be greater than 4 (i.e. it must at least fit a 4-byte utf-8 char).
+   * 
+   * Default: `4 * 1024 * 1024` = `4194304`
+   */
+  bufferSize?: number,
+  /**
+   * The path to the Worker's main script or module.
+   * Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with ./ or ../, or a WHATWG URL object using file: or data: protocol.
+   * When using a data: URL, the data is interpreted based on MIME type using the ECMAScript module loader.
+   * 
+   * {@link workerThreads.Worker()}
+   */
+  filename: string | URL,
+  /**
+   * If `true`, write data synchronously; otherwise write data asynchronously.
+   * 
+   * Default: `false`.
+   */
+  sync?: boolean,
+  /**
+   * {@link workerThreads.WorkerOptions.workerData}
+   * 
+   * Default: `{}`
+   */
+  workerData?: any,
+  /**
+   * {@link workerThreads.WorkerOptions}
+   * 
+   * Default: `{}`
+   */
+  workerOpts?: workerThreads.WorkerOptions
+}
+
+
+declare class ThreadStream extends EventEmitter {
+  /**
+   * @param {ThreadStreamOptions} opts 
+   */
+  constructor(opts: ThreadStreamOptions)
+  /**
+   * Write some data to the stream.
+   * 
+   * **Please note that this method should not throw an {Error} if something goes wrong but emit an error event.**
+   * @param {string} data data to write.
+   * @returns {boolean} false if the stream wishes for the calling code to wait for the 'drain' event to be emitted before continuing to write additional data or if it fails to write; otherwise true.
+   */
+  write(data: string): boolean
+  /**
+   * Signal that no more data will be written.
+   * 
+   * **Please note that this method should not throw an {Error} if something goes wrong but emit an error event.**
+   * 
+   * Calling the {@link write()} method after calling {@link end()} will emit an error.
+   */
+  end(): void
+  /**
+   * Flush the stream synchronously.
+   * This method should be called in the shutdown phase to make sure that all data has been flushed.
+   * 
+   * **Please note that this method will throw an {Error} if something goes wrong.**
+   * 
+   * @throws {Error} if the stream is already flushing, if it fails to flush or if it takes more than 10 seconds to flush.
+   */
+  flushSync(): void
+  /**
+   * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments
+   * to each.
+   *
+   * @param eventName the name of the event.
+   * @param args the arguments to be passed to the event handlers.
+   * @returns {boolean} `true` if the event had listeners, `false` otherwise.
+   */
+  emit(eventName: string | symbol, ...args: any[]): boolean;
+
+  /**
+   * Post a message to the Worker with specified data and an optional list of transferable objects.
+   *
+   * @param eventName the name of the event, specifically 'message'.
+   * @param message message data to be sent to the Worker.
+   * @param transferList an optional list of transferable objects to be transferred to the Worker context.
+   * @returns {boolean} true if the event had listeners, false otherwise.
+   */
+  emit(eventName: 'message', message: any, transferList?: workerThreads.TransferListItem[]): boolean
+}
+
+export = ThreadStream;