@scalar/schemas 0.13.1 → 0.13.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @scalar/schemas
 
+## 0.13.2
+
+### Patch Changes
+
+- [#10554](https://github.com/scalar/scalar/pull/10554): Render AsyncAPI boolean schemas with explanations in message payloads, headers, and reusable models.
+- [#10565](https://github.com/scalar/scalar/pull/10565): Inherit AsyncAPI operation metadata and replies from traits using recursive merge rules, and use inherited titles in navigation.
+
 ## 0.13.1
 
 ## 0.13.0

package/dist/asyncapi/3.1/operation-trait.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation-trait.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/operation-trait.ts"],"names":[],"mappings":"AAQA,gDAAgD;AAChD,eAAO,MAAM,4BAA4B,qCAuBxC,CAAA"}
+{"version":3,"file":"operation-trait.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/operation-trait.ts"],"names":[],"mappings":"AASA,gDAAgD;AAChD,eAAO,MAAM,4BAA4B,qCAwBxC,CAAA"}

package/dist/asyncapi/3.1/operation-trait.js

@@ -1,6 +1,7 @@
 import { array, object, optional, string } from '@scalar/validation';
 import { asyncApiOperationBindingsObject } from './bindings.js';
 import { asyncApiExternalDocumentationObject } from './external-documentation.js';
+import { asyncApiOperationReplyObject } from './operation-reply.js';
 import { recursiveRef } from './reference.js';
 import { asyncApiSecuritySchemeObject } from './security-scheme.js';
 import { asyncApiTagsObject } from './tag.js';
@@ -17,4 +18,5 @@ export const asyncApiOperationTraitObject = recursiveRef(object({
     tags: optional(asyncApiTagsObject),
     externalDocs: optional(asyncApiExternalDocumentationObject),
     bindings: optional(recursiveRef(asyncApiOperationBindingsObject)),
+    reply: optional(asyncApiOperationReplyObject),
 }, { typeName: 'AsyncApiOperationTraitObject' }));

package/dist/asyncapi/3.1/schema-payload.js

@@ -1,5 +1,5 @@
 import { literal, object, optional, string, union, unknown } from '@scalar/validation';
-import { schema as schemaObject } from '../../openapi/3.1/schema.js';
+import { createSchema } from '../../openapi/3.1/schema.js';
 import { recursiveRef } from './reference.js';
 export const asyncApiMultiFormatSchemaObject = object({
     schemaFormat: optional(string({
@@ -11,7 +11,7 @@ export const asyncApiMultiFormatSchemaObject = object({
 }, { typeName: 'AsyncApiMultiFormatSchemaObject' });
 // AsyncAPI's default schema format is JSON Schema, the same dialect OpenAPI 3.1 uses, so we reuse the
 // OpenAPI Schema Object here instead of an opaque `unknown`. A schema may also be a boolean per JSON Schema.
-const asyncApiSchemaJsonShape = union([literal(true), literal(false), schemaObject], {
+const asyncApiSchemaJsonShape = union([literal(true), literal(false), createSchema(true)], {
     typeName: 'AsyncApiSchemaJsonShape',
 });
 /** Schema Object | Reference Object */

package/dist/openapi/3.1/schema.d.ts

@@ -1,3 +1,8 @@
 import { type Schema } from '@scalar/validation';
+/**
+ * Build the shared Schema Object shape, optionally accepting boolean child schemas.
+ * AsyncAPI uses JSON Schema booleans recursively; the OpenAPI ingestion pipeline normalizes them first.
+ */
+export declare const createSchema: (booleanSchemas?: boolean) => Schema;
 export declare const schema: Schema;
 //# sourceMappingURL=schema.d.ts.map

package/dist/openapi/3.1/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAaZ,MAAM,oBAAoB,CAAA;AA0K3B,eAAO,MAAM,MAAM,EAAE,MAOpB,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAaZ,MAAM,oBAAoB,CAAA;AAS3B;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,wBAAsB,KAAG,MA6KrD,CAAA;AAED,eAAO,MAAM,MAAM,QAAiB,CAAA"}

package/dist/openapi/3.1/schema.js

@@ -5,128 +5,137 @@ import { discriminatorObject } from '../../openapi/3.1/discriminator.js';
 import { externalDocs } from '../../openapi/3.1/external-docs.js';
 import { normalRef } from '../../openapi/3.1/reference.js';
 import { xml } from '../../openapi/3.1/xml.js';
-const schemaExtensionObjects = [
-    XScalarIgnore,
-    XInternal,
-    XVariable,
-    XExamples,
-    XEnumDescriptions,
-    XEnumVarNames,
-    XAdditionalPropertiesName,
-    XTags,
-];
-const coreSchemaProperties = object({
-    name: optional(string({ typeComment: 'Schema name (extension).' })),
-    title: optional(string({ typeComment: 'A title for the schema.' })),
-    description: optional(string({ typeComment: 'A description of the schema.' })),
-    default: optional(any({ typeComment: 'Default value for the schema.' })),
-    enum: optional(array(any(), { typeComment: 'Array of allowed values.', typeName: 'JsonSchemaEnum' })),
-    const: optional(any({ typeComment: 'Constant value that must match exactly.' })),
-    contentMediaType: optional(string({ typeComment: 'Media type for content validation.' })),
-    contentEncoding: optional(string({ typeComment: 'Content encoding.' })),
-    contentSchema: optional(normalRef(lazy(() => schema))),
-    deprecated: optional(boolean({ typeComment: 'Whether the schema is deprecated.' })),
-    discriminator: optional(discriminatorObject),
-    readOnly: optional(boolean({ typeComment: 'Whether the schema is read-only.' })),
-    writeOnly: optional(boolean({ typeComment: 'Whether the schema is write-only.' })),
-    xml: optional(xml),
-    externalDocs: optional(externalDocs),
-    example: optional(any({
-        typeComment: 'A free-form field to include an example of an instance for this schema. Deprecated in favor of the JSON Schema examples keyword.',
-    })),
-    examples: optional(array(any(), {
-        typeComment: 'An array of examples of valid instances for this schema. This keyword follows the JSON Schema Draft 2020-12 specification.',
-        typeName: 'SchemaExamplesArray',
-    })),
-    allOf: optional(array(normalRef(lazy(() => schema)), { typeName: 'SchemaObjectAllOf' })),
-    oneOf: optional(array(normalRef(lazy(() => schema)), { typeName: 'SchemaObjectOneOf' })),
-    anyOf: optional(array(normalRef(lazy(() => schema)), { typeName: 'SchemaObjectAnyOf' })),
-    not: optional(normalRef(lazy(() => schema))),
-});
-const numericValidationKeywords = object({
-    multipleOf: optional(number({ typeComment: 'Number must be a multiple of this value.' })),
-    maximum: optional(number({ typeComment: 'Maximum value (inclusive).' })),
-    exclusiveMaximum: optional(number({ typeComment: 'Maximum value (exclusive).' })),
-    minimum: optional(number({ typeComment: 'Minimum value (inclusive).' })),
-    exclusiveMinimum: optional(number({ typeComment: 'Minimum value (exclusive).' })),
-});
-const numericSchema = intersection([
-    object({
-        type: union([literal('number'), literal('integer')]),
-        format: optional(string({ typeComment: 'Different subtypes.' })),
-    }),
-    numericValidationKeywords,
-], { typeName: 'NumberSchemaObject' });
-const stringValidationKeywords = object({
-    maxLength: optional(number({ typeComment: 'Maximum string length.' })),
-    minLength: optional(number({ typeComment: 'Minimum string length.' })),
-    pattern: optional(string({ typeComment: 'Regular expression pattern.' })),
-});
-const stringSchema = intersection([
-    object({
-        type: literal('string'),
-        format: optional(string({ typeComment: 'Different subtypes.' })),
-    }),
-    stringValidationKeywords,
-], { typeName: 'StringSchemaObject' });
-const objectValidationKeywords = object({
-    maxProperties: optional(number({ typeComment: 'Maximum number of properties.' })),
-    minProperties: optional(number({ typeComment: 'Minimum number of properties.' })),
-    properties: optional(record(string(), normalRef(lazy(() => schema)), { typeName: 'SchemaObjectProperties' })),
-    required: optional(array(string(), { typeName: 'SchemaObjectRequired' })),
-    additionalProperties: optional(union([normalRef(lazy(() => schema)), object({}), boolean()], {
-        typeName: 'SchemaObjectAdditionalProperties',
-    })),
-    patternProperties: optional(record(string(), normalRef(lazy(() => schema)), { typeName: 'SchemaObjectPatternProperties' })),
-    propertyNames: optional(normalRef(lazy(() => schema))),
-});
-const objectSchema = intersection([
-    object({
-        type: literal('object'),
-    }),
-    objectValidationKeywords,
-], { typeName: 'ObjectSchemaObject' });
-const arrayValidationKeywords = object({
-    maxItems: optional(number({ typeComment: 'Maximum number of items in array.' })),
-    minItems: optional(number({ typeComment: 'Minimum number of items in array.' })),
-    uniqueItems: optional(boolean({ typeComment: 'Whether array items must be unique.' })),
-    items: optional(normalRef(lazy(() => schema))),
-    prefixItems: optional(array(normalRef(lazy(() => schema)), { typeComment: 'Schema for tuple validation.' })),
-});
-const arraySchema = intersection([
-    object({
-        type: literal('array'),
-    }),
-    arrayValidationKeywords,
-], { typeName: 'ArraySchemaObject' });
-const schemaTypeMulti = union([
-    literal('null'),
-    literal('boolean'),
-    literal('string'),
-    literal('number'),
-    literal('integer'),
-    literal('object'),
-    literal('array'),
-], { typeName: 'SchemaObjectMultiTypeKeywords' });
-const otherTypeSchema = object({
-    type: union([literal('null'), literal('boolean')], {
-        typeName: 'SchemaObjectOtherTypeKeyword',
-    }),
-});
-const multiTypeSchema = intersection([
-    object({
-        type: array(schemaTypeMulti, {
-            typeName: 'SchemaObjectMultiTypeKeywordArray',
+/**
+ * Build the shared Schema Object shape, optionally accepting boolean child schemas.
+ * AsyncAPI uses JSON Schema booleans recursively; the OpenAPI ingestion pipeline normalizes them first.
+ */
+export const createSchema = (booleanSchemas = false) => {
+    const schemaExtensionObjects = [
+        XScalarIgnore,
+        XInternal,
+        XVariable,
+        XExamples,
+        XEnumDescriptions,
+        XEnumVarNames,
+        XAdditionalPropertiesName,
+        XTags,
+    ];
+    const coreSchemaProperties = object({
+        name: optional(string({ typeComment: 'Schema name (extension).' })),
+        title: optional(string({ typeComment: 'A title for the schema.' })),
+        description: optional(string({ typeComment: 'A description of the schema.' })),
+        default: optional(any({ typeComment: 'Default value for the schema.' })),
+        enum: optional(array(any(), { typeComment: 'Array of allowed values.', typeName: 'JsonSchemaEnum' })),
+        const: optional(any({ typeComment: 'Constant value that must match exactly.' })),
+        contentMediaType: optional(string({ typeComment: 'Media type for content validation.' })),
+        contentEncoding: optional(string({ typeComment: 'Content encoding.' })),
+        contentSchema: optional(normalRef(lazy(() => nestedSchema))),
+        deprecated: optional(boolean({ typeComment: 'Whether the schema is deprecated.' })),
+        discriminator: optional(discriminatorObject),
+        readOnly: optional(boolean({ typeComment: 'Whether the schema is read-only.' })),
+        writeOnly: optional(boolean({ typeComment: 'Whether the schema is write-only.' })),
+        xml: optional(xml),
+        externalDocs: optional(externalDocs),
+        example: optional(any({
+            typeComment: 'A free-form field to include an example of an instance for this schema. Deprecated in favor of the JSON Schema examples keyword.',
+        })),
+        examples: optional(array(any(), {
+            typeComment: 'An array of examples of valid instances for this schema. This keyword follows the JSON Schema Draft 2020-12 specification.',
+            typeName: 'SchemaExamplesArray',
+        })),
+        allOf: optional(array(normalRef(lazy(() => nestedSchema)), { typeName: 'SchemaObjectAllOf' })),
+        oneOf: optional(array(normalRef(lazy(() => nestedSchema)), { typeName: 'SchemaObjectOneOf' })),
+        anyOf: optional(array(normalRef(lazy(() => nestedSchema)), { typeName: 'SchemaObjectAnyOf' })),
+        not: optional(normalRef(lazy(() => nestedSchema))),
+    });
+    const numericValidationKeywords = object({
+        multipleOf: optional(number({ typeComment: 'Number must be a multiple of this value.' })),
+        maximum: optional(number({ typeComment: 'Maximum value (inclusive).' })),
+        exclusiveMaximum: optional(number({ typeComment: 'Maximum value (exclusive).' })),
+        minimum: optional(number({ typeComment: 'Minimum value (inclusive).' })),
+        exclusiveMinimum: optional(number({ typeComment: 'Minimum value (exclusive).' })),
+    });
+    const numericSchema = intersection([
+        object({
+            type: union([literal('number'), literal('integer')]),
+            format: optional(string({ typeComment: 'Different subtypes.' })),
         }),
-        format: optional(string({ typeComment: 'Different subtypes.' })),
-    }),
-    numericValidationKeywords,
-    stringValidationKeywords,
-    arrayValidationKeywords,
-    objectValidationKeywords,
-], { typeName: 'MultiTypeSchemaObject' });
-export const schema = intersection([
-    coreSchemaProperties,
-    ...schemaExtensionObjects,
-    union([otherTypeSchema, numericSchema, stringSchema, objectSchema, arraySchema, multiTypeSchema, object({})]),
-], { typeName: 'SchemaObject' });
+        numericValidationKeywords,
+    ], { typeName: 'NumberSchemaObject' });
+    const stringValidationKeywords = object({
+        maxLength: optional(number({ typeComment: 'Maximum string length.' })),
+        minLength: optional(number({ typeComment: 'Minimum string length.' })),
+        pattern: optional(string({ typeComment: 'Regular expression pattern.' })),
+    });
+    const stringSchema = intersection([
+        object({
+            type: literal('string'),
+            format: optional(string({ typeComment: 'Different subtypes.' })),
+        }),
+        stringValidationKeywords,
+    ], { typeName: 'StringSchemaObject' });
+    const objectValidationKeywords = object({
+        maxProperties: optional(number({ typeComment: 'Maximum number of properties.' })),
+        minProperties: optional(number({ typeComment: 'Minimum number of properties.' })),
+        properties: optional(record(string(), normalRef(lazy(() => nestedSchema)), { typeName: 'SchemaObjectProperties' })),
+        required: optional(array(string(), { typeName: 'SchemaObjectRequired' })),
+        additionalProperties: optional(union([normalRef(lazy(() => nestedSchema)), object({}), boolean()], {
+            typeName: 'SchemaObjectAdditionalProperties',
+        })),
+        patternProperties: optional(record(string(), normalRef(lazy(() => nestedSchema)), { typeName: 'SchemaObjectPatternProperties' })),
+        propertyNames: optional(normalRef(lazy(() => nestedSchema))),
+    });
+    const objectSchema = intersection([
+        object({
+            type: literal('object'),
+        }),
+        objectValidationKeywords,
+    ], { typeName: 'ObjectSchemaObject' });
+    const arrayValidationKeywords = object({
+        maxItems: optional(number({ typeComment: 'Maximum number of items in array.' })),
+        minItems: optional(number({ typeComment: 'Minimum number of items in array.' })),
+        uniqueItems: optional(boolean({ typeComment: 'Whether array items must be unique.' })),
+        items: optional(normalRef(lazy(() => nestedSchema))),
+        prefixItems: optional(array(normalRef(lazy(() => nestedSchema)), { typeComment: 'Schema for tuple validation.' })),
+    });
+    const arraySchema = intersection([
+        object({
+            type: literal('array'),
+        }),
+        arrayValidationKeywords,
+    ], { typeName: 'ArraySchemaObject' });
+    const schemaTypeMulti = union([
+        literal('null'),
+        literal('boolean'),
+        literal('string'),
+        literal('number'),
+        literal('integer'),
+        literal('object'),
+        literal('array'),
+    ], { typeName: 'SchemaObjectMultiTypeKeywords' });
+    const otherTypeSchema = object({
+        type: union([literal('null'), literal('boolean')], {
+            typeName: 'SchemaObjectOtherTypeKeyword',
+        }),
+    });
+    const multiTypeSchema = intersection([
+        object({
+            type: array(schemaTypeMulti, {
+                typeName: 'SchemaObjectMultiTypeKeywordArray',
+            }),
+            format: optional(string({ typeComment: 'Different subtypes.' })),
+        }),
+        numericValidationKeywords,
+        stringValidationKeywords,
+        arrayValidationKeywords,
+        objectValidationKeywords,
+    ], { typeName: 'MultiTypeSchemaObject' });
+    const schema = intersection([
+        coreSchemaProperties,
+        ...schemaExtensionObjects,
+        union([otherTypeSchema, numericSchema, stringSchema, objectSchema, arraySchema, multiTypeSchema, object({})]),
+    ], { typeName: 'SchemaObject' });
+    const nestedSchema = booleanSchemas ? union([boolean(), schema]) : schema;
+    return schema;
+};
+export const schema = createSchema();

package/package.json

@@ -14,7 +14,7 @@
     "schemas",
     "scalar"
   ],
-  "version": "0.13.1",
+  "version": "0.13.2",
   "engines": {
     "node": ">=22"
   },
@@ -41,11 +41,11 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@scalar/helpers": "0.16.2",
-    "@scalar/validation": "0.6.6"
+    "@scalar/helpers": "0.16.3",
+    "@scalar/validation": "0.6.7"
   },
   "devDependencies": {
-    "@scalar/types": "0.23.1",
+    "@scalar/types": "0.23.2",
     "vitest": "4.1.10"
   },
   "scripts": {