@zuplo/cli 6.69.4 → 6.69.6

package/node_modules/@zuplo/editor/node_modules/fast-json-stringify/test/issue-836.test.js

@@ -0,0 +1,183 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('external $ref schema should be reused, not inlined at every reference', (t) => {
+  t.plan(3)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' },
+      email: { type: 'string' }
+    }
+  }
+
+  // Schema referencing the same external $ref multiple times
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      owner: { $ref: 'contact.json' },
+      assignee: { $ref: 'contact.json' },
+      reporter: { $ref: 'contact.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+  const code = serializer.toString()
+
+  // The serialized function should contain extracted anonymous functions
+  // rather than inlining the full contact schema at every reference.
+  // With the fix, `firstName` appears 0 times in the main serializer body
+  // (it is inside the extracted function, which is not included in .toString())
+  // or at most 1 time if in a single extracted function.
+  const firstNameMatches = code.match(/firstName/g)
+  t.assert.ok(firstNameMatches === null || firstNameMatches.length <= 1,
+    `firstName should appear at most once (extracted function), got ${firstNameMatches ? firstNameMatches.length : 0}`)
+
+  // Verify correct serialization
+  const data = {
+    owner: { firstName: 'John', lastName: 'Doe', email: 'john@example.com' },
+    assignee: { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },
+    reporter: { firstName: 'Bob', lastName: 'Jones', email: 'bob@example.com' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external $ref schema reused with anyOf wrapping', (t) => {
+  t.plan(2)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' },
+      email: { type: 'string' }
+    }
+  }
+
+  // Common pattern: anyOf wrapping $ref for polymorphic fields (populated object OR string ID OR null)
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      owner: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      },
+      assignee: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      },
+      reporter: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+
+  // Serialize with populated objects
+  const data = {
+    owner: { firstName: 'John', lastName: 'Doe', email: 'john@example.com' },
+    assignee: { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },
+    reporter: { firstName: 'Bob', lastName: 'Jones', email: 'bob@example.com' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external $ref schema reused in array items', (t) => {
+  t.plan(2)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' }
+    }
+  }
+
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      contacts: {
+        type: 'array',
+        items: { $ref: 'contact.json' }
+      },
+      primary: { $ref: 'contact.json' },
+      secondary: { $ref: 'contact.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+
+  const data = {
+    contacts: [
+      { firstName: 'Alice', lastName: 'Wonder' },
+      { firstName: 'Bob', lastName: 'Builder' }
+    ],
+    primary: { firstName: 'Charlie', lastName: 'Charm' },
+    secondary: { firstName: 'Diana', lastName: 'Prince' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external array $ref schema should be reused, not inlined at every reference', (t) => {
+  t.plan(2)
+
+  const tagsSchema = {
+    $id: 'tags.json',
+    type: 'array',
+    items: { type: 'string' }
+  }
+
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      a: { $ref: 'tags.json' },
+      b: { $ref: 'tags.json' },
+      c: { $ref: 'tags.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'tags.json': tagsSchema } })
+
+  const data = {
+    a: ['x', 'y'],
+    b: ['z'],
+    c: []
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('inline anonymous schemas should still be inlined (not extracted)', (t) => {
+  t.plan(1)
+
+  // Inline schemas (no external $ref) should continue to work normally
+  const schema = {
+    type: 'object',
+    properties: {
+      a: { type: 'object', properties: { x: { type: 'string' } } },
+      b: { type: 'object', properties: { x: { type: 'string' } } }
+    }
+  }
+
+  const serializer = build(schema)
+  const output = serializer({ a: { x: 'hello' }, b: { x: 'world' } })
+
+  t.assert.equal(output, '{"a":{"x":"hello"},"b":{"x":"world"}}')
+})

package/node_modules/@zuplo/editor/node_modules/fast-json-stringify/test/json-add-comma.test.js

@@ -1,57 +1,57 @@
-'use strict'
-
-const { test } = require('node:test')
-const build = require('..')
-
-test('additionalProperties: false', (t) => {
-  t.plan(1)
-  const stringify = build({
-    title: 'additionalProperties',
-    type: 'object',
-    properties: {
-      foo: {
-        type: 'string'
-      }
-    },
-    additionalProperties: false
-  })
-
-  const obj = { foo: 'a', bar: 'b', baz: 'c' }
-  t.assert.equal(stringify(obj), '{"foo":"a"}')
-})
-
-test('additionalProperties: {}', (t) => {
-  t.plan(1)
-  const stringify = build({
-    title: 'additionalProperties',
-    type: 'object',
-    properties: {
-      foo: {
-        type: 'string'
-      }
-    },
-    additionalProperties: {}
-  })
-
-  const obj = { foo: 'a', bar: 'b', baz: 'c' }
-  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
-})
-
-test('additionalProperties: {type: string}', (t) => {
-  t.plan(1)
-  const stringify = build({
-    title: 'additionalProperties',
-    type: 'object',
-    properties: {
-      foo: {
-        type: 'string'
-      }
-    },
-    additionalProperties: {
-      type: 'string'
-    }
-  })
-
-  const obj = { foo: 'a', bar: 'b', baz: 'c' }
-  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
-})
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('additionalProperties: false', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: false
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a"}')
+})
+
+test('additionalProperties: {}', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {}
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
+})
+
+test('additionalProperties: {type: string}', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {
+      type: 'string'
+    }
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
+})

package/node_modules/@zuplo/editor/node_modules/fast-json-stringify/test/oneof.test.js

@@ -488,3 +488,23 @@ test('all array items does not match oneOf types', (t) => {
 
   t.assert.throws(() => stringify({ data: [null, false, true, undefined, [], {}] }))
 })
+
+test('invalid oneOf schema', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: 'not array'  // invalid, oneOf must be array
+      }
+    }
+  }
+
+  try {
+    build(schema)
+    t.assert.fail('Should throw')
+  } catch (err) {
+    t.assert.ok(err.message.includes('schema is invalid'))
+  }
+})

package/node_modules/@zuplo/editor/node_modules/fast-json-stringify/test/ref.test.js

@@ -2044,3 +2044,34 @@ test('ref internal - throw if schema has definition twice with different shape',
     t.assert.equal(err.message, 'There is already another anchor "#uri" in schema "test".')
   }
 })
+
+test('ref nested', (t) => {
+  t.plan(2)
+
+  const schema = {
+    definitions: {
+      def1: {
+        $ref: '#/definitions/def2'
+      },
+      def2: {
+        type: 'string'
+      }
+    },
+    type: 'object',
+    properties: {
+      str: {
+        $ref: '#/definitions/def1'
+      }
+    }
+  }
+
+  const object = {
+    str: 'test'
+  }
+
+  const stringify = build(schema)
+  const output = stringify(object)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"str":"test"}')
+})

package/node_modules/@zuplo/editor/node_modules/fast-json-stringify/test/typebox.test.js

@@ -4,7 +4,7 @@ const { test } = require('node:test')
 const build = require('..')
 
 test('nested object in pattern properties for typebox', (t) => {
-  const { Type } = require('@sinclair/typebox')
+  const { Type } = require('typebox')
 
   t.plan(1)
 

package/node_modules/@zuplo/editor/node_modules/fast-json-stringify/types/{index.test-d.ts → index.tst.ts}

@@ -1,7 +1,7 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Test using this disabled, see https://github.com/fastify/fast-json-stringify/pull/683
 import Ajv from 'ajv'
 import build, { restore, Schema, validLargeArrayMechanisms } from '..'
-import { expectError, expectType } from 'tsd'
+import { expect } from 'tstyche'
 
 // Number schemas
 build({
@@ -26,9 +26,10 @@ build({
 build({
   type: 'number'
 }, { rounding: 'trunc' })
-expectError(build({
+
+expect(build).type.not.toBeCallableWith({
   type: 'number'
-}, { rounding: 'invalid' }))
+}, { rounding: 'invalid' })
 
 // String schema
 build({
@@ -153,7 +154,6 @@ build({
 })({ something: 'a string', somethingElse: 42 })
 
 // String schema with format
-
 build({
   type: 'string',
   format: 'date-time'
@@ -181,7 +181,6 @@ str = build({
     type: 'number'
 }, { mode: 'standalone' })
 */
-
 const debugCompiled = build({
   title: 'default string',
   type: 'object',
@@ -191,11 +190,12 @@ const debugCompiled = build({
     }
   }
 }, { mode: 'debug' })
-expectType<ReturnType<typeof build>>(build.restore(debugCompiled))
-expectType<ReturnType<typeof build>>(restore(debugCompiled))
 
-expectType<string[]>(build.validLargeArrayMechanisms)
-expectType<string[]>(validLargeArrayMechanisms)
+expect(build.restore(debugCompiled)).type.toBe(build({} as Schema))
+expect(restore(debugCompiled)).type.toBe(build({} as Schema))
+
+expect(build.validLargeArrayMechanisms).type.toBe<string[]>()
+expect(validLargeArrayMechanisms).type.toBe<string[]>()
 
 /**
  * Schema inference
@@ -211,10 +211,11 @@ const stringify3 = build({
   type: 'object',
   properties: { a: { type: 'string' } },
 })
+
 stringify3<InferenceSchema>({ id: '123' })
 stringify3<InferenceSchema>({ a: 123, id: '123' })
-expectError(stringify3<InferenceSchema>({ anotherOne: 'bar' }))
-expectError(stringify3<Schema>({ a: 'bar' }))
+expect(stringify3<InferenceSchema>).type.not.toBeCallableWith({ anotherOne: 'bar' })
+expect(stringify3<Schema>).type.not.toBeCallableWith({ a: 'bar' })
 
 // Without inference
 const stringify4 = build({
@@ -231,29 +232,28 @@ const stringify5 = build({
   type: 'string',
 })
 stringify5('foo')
-expectError(stringify5({ id: '123' }))
+expect(stringify5).type.not.toBeCallableWith({ id: '123' })
 
 // Without inference - null type
 const stringify6 = build({
   type: 'null',
 })
 stringify6(null)
-expectError(stringify6('a string'))
+expect(stringify6).type.not.toBeCallableWith('a string')
 
 // Without inference - boolean type
 const stringify7 = build({
   type: 'boolean',
 })
 stringify7(true)
-expectError(stringify7('a string'))
+expect(stringify7).type.not.toBeCallableWith('a string')
 
 // largeArrayMechanism
-
 build({}, { largeArrayMechanism: 'json-stringify' })
 build({}, { largeArrayMechanism: 'default' })
-expectError(build({} as Schema, { largeArrayMechanism: 'invalid' }))
+expect(build).type.not.toBeCallableWith({} as Schema, { largeArrayMechanism: 'invalid' })
 
 build({}, { largeArraySize: 2000 })
 build({}, { largeArraySize: '2e4' })
 build({}, { largeArraySize: 2n })
-expectError(build({} as Schema, { largeArraySize: ['asdf'] }))
+expect(build).type.not.toBeCallableWith({} as Schema, { largeArraySize: ['asdf'] })

package/node_modules/@zuplo/editor/node_modules/lru-cache/dist/commonjs/browser/diagnostics-channel-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-channel-browser.d.ts","sourceRoot":"","sources":["../../../src/diagnostics-channel-browser.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAA;AACjC,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,CAAA;AAGvC,eAAO,MAAM,OAAO,EAAY,OAAO,CAAC,OAAO,CAAC,CAAA;AAChD,eAAO,MAAM,OAAO,EAAY,cAAc,CAAC,OAAO,CAAC,CAAA"}

package/node_modules/@zuplo/editor/node_modules/lru-cache/dist/commonjs/browser/diagnostics-channel-browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-channel-browser.js","sourceRoot":"","sources":["../../../src/diagnostics-channel-browser.ts"],"names":[],"mappings":";;;AAQA,MAAM,KAAK,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,CAAA;AAC1B,QAAA,OAAO,GAAG,KAAyB,CAAA;AACnC,QAAA,OAAO,GAAG,KAAgC,CAAA","sourcesContent":["// this is used in ESM environments that follow the 'browser' import\n// condition, to avoid even trying to load node:diagnostics_channel\nimport {\n  type Channel,\n  type TracingChannel,\n} from 'node:diagnostics_channel'\nexport type { TracingChannel, Channel }\n\nconst dummy = { hasSubscribers: false }\nexport const metrics = dummy as Channel<unknown>\nexport const tracing = dummy as TracingChannel<unknown>\n"]}

package/node_modules/@zuplo/editor/node_modules/lru-cache/dist/commonjs/browser/diagnostics-channel.d.ts

@@ -0,0 +1,5 @@
+import { type Channel, type TracingChannel } from 'node:diagnostics_channel';
+export type { TracingChannel, Channel };
+export declare const metrics: Channel<unknown>;
+export declare const tracing: TracingChannel<unknown>;
+//# sourceMappingURL=diagnostics-channel-browser.d.ts.map

package/node_modules/@zuplo/editor/node_modules/lru-cache/dist/commonjs/browser/diagnostics-channel.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracing = exports.metrics = void 0;
+const dummy = { hasSubscribers: false };
+exports.metrics = dummy;
+exports.tracing = dummy;
+//# sourceMappingURL=diagnostics-channel-browser.js.map