svelte-reflector 2.1.6 → 2.1.8

package/dist/core/openapi/InlineSchemaPromoter.js

@@ -49,7 +49,22 @@ export class InlineSchemaPromoter {
         while (queue.length > 0) {
             const schemaName = queue.shift();
             const schema = schemas[schemaName];
-            if (!schema || "$ref" in schema || !schema.properties)
+            if (!schema || "$ref" in schema)
+                continue;
+            // Array-root schema (e.g. a promoted `data: array` response): promote its
+            // inline-object items to a named `${schemaName}Item` so they get a typed
+            // child schema instead of staying inline and degrading to `string[]`.
+            if (!schema.properties && schema.type === "array") {
+                const inlineItems = InlineSchemaPromoter.extractableInlineArrayItems(schema);
+                if (inlineItems) {
+                    const name = InlineSchemaPromoter.reserveNestedName(usedNames, schemaName, "item");
+                    schemas[name] = inlineItems;
+                    queue.push(name);
+                    schema.items = { $ref: `#/components/schemas/${name}` };
+                }
+                continue;
+            }
+            if (!schema.properties)
                 continue;
             for (const [propKey, propValue] of Object.entries(schema.properties)) {
                 if (isReferenceObject(propValue))

package/dist/core/schema/ArraySchemaRenderer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Renders the wrapper class + interface alias for an array-root schema — a
+ * component whose top level is `type: array` (e.g. a promoted `data: array`
+ * response envelope). Unlike object schemas (handled by `SchemaClassRenderer`),
+ * the interface is a bare array alias (`type XInterface = ItemInterface[]`)
+ * because the response envelope's `data` is already unwrapped: the consumer
+ * calls `new X({ data: response })` with `response` being the array itself.
+ */
+export declare class ArraySchemaRenderer {
+    static render(params: {
+        name: string;
+        elementType: string;
+        isRef: boolean;
+    }): {
+        interface: string;
+        schema: string;
+    };
+}

package/dist/core/schema/ArraySchemaRenderer.js

@@ -0,0 +1,39 @@
+/**
+ * Renders the wrapper class + interface alias for an array-root schema — a
+ * component whose top level is `type: array` (e.g. a promoted `data: array`
+ * response envelope). Unlike object schemas (handled by `SchemaClassRenderer`),
+ * the interface is a bare array alias (`type XInterface = ItemInterface[]`)
+ * because the response envelope's `data` is already unwrapped: the consumer
+ * calls `new X({ data: response })` with `response` being the array itself.
+ */
+export class ArraySchemaRenderer {
+    static render(params) {
+        const { name, elementType, isRef } = params;
+        const interfaceElement = isRef ? `${elementType}Interface` : elementType;
+        const interfaceAlias = `export type ${name}Interface = ${interfaceElement}[]`;
+        const constructorBody = isRef
+            ? `this.data = params?.data?.map((item) => new ${elementType}({ data: item })) ?? []`
+            : `this.data = params?.data ?? []`;
+        const staticBody = isRef
+            ? `return data.map((item) => new ${elementType}({ data: item }))`
+            : `return data`;
+        const bundleBody = isRef ? `return this.data.map((item) => item.bundle())` : `return this.data`;
+        const schema = `
+    export class ${name} {
+      data = $state<${elementType}[]>([]);
+
+      constructor(params?: { data?: ${name}Interface | undefined, empty?: boolean }) {
+        ${constructorBody}
+      }
+
+      static from(data: ${name}Interface) {
+        ${staticBody}
+      }
+
+      bundle(): ${name}Interface {
+        ${bundleBody}
+      }
+    };`;
+        return { interface: interfaceAlias, schema };
+    }
+}

package/dist/core/schema/Schema.d.ts

@@ -19,6 +19,27 @@ export declare class Schema {
     readonly customTypeDeps: string[];
     schema: string;
     interface: string;
+    /**
+     * Builds a Schema for an array-root component (top-level `type: array`), e.g.
+     * a promoted `data: array` response envelope. Renders a wrapper class whose
+     * `data` is `Item[]` (hydrated `new Item({ data })` when items are a `$ref`)
+     * and whose interface is a bare array alias. Object-root schemas use the
+     * regular constructor instead.
+     */
+    static forArrayRoot(params: {
+        name: string;
+        items: SchemaObject | ReferenceObject;
+        context: CodegenContext;
+    }): Schema;
+    /**
+     * Resolves the element type of an array-root schema. Inline-object items are
+     * already promoted to a `$ref` by `InlineSchemaPromoter`, so by here items is
+     * a `$ref`, an enum, a free-form object (→ `Record<string, unknown>`), or a
+     * primitive. `ArrayProp` is reused for ref/enum/primitive (it also registers
+     * the enum type in the context); the free-form object is special-cased
+     * because `ArrayProp.getType` would degrade it to `string`.
+     */
+    private static resolveArrayElement;
     constructor(params: {
         properties: Record<string, SchemaObject | ReferenceObject>;
         name: string;

package/dist/core/schema/Schema.js

@@ -2,9 +2,11 @@ import { ArrayProp } from "../../props/array.property.js";
 import { EnumProp } from "../../props/enum.property.js";
 import { ObjectProp } from "../../props/object.property.js";
 import { PrimitiveProp } from "../../props/primitive.property.js";
+import { isReferenceObject } from "../../helpers/helpers.js";
 import { SchemaPropertyClassifier } from "./SchemaPropertyClassifier.js";
 import { SchemaDependencyCollector } from "./SchemaDependencyCollector.js";
 import { SchemaClassRenderer } from "./SchemaClassRenderer.js";
+import { ArraySchemaRenderer } from "./ArraySchemaRenderer.js";
 export class Schema {
     name;
     primitiveProps = [];
@@ -19,6 +21,63 @@ export class Schema {
     customTypeDeps;
     schema;
     interface;
+    /**
+     * Builds a Schema for an array-root component (top-level `type: array`), e.g.
+     * a promoted `data: array` response envelope. Renders a wrapper class whose
+     * `data` is `Item[]` (hydrated `new Item({ data })` when items are a `$ref`)
+     * and whose interface is a bare array alias. Object-root schemas use the
+     * regular constructor instead.
+     */
+    static forArrayRoot(params) {
+        const { name, items, context } = params;
+        const element = Schema.resolveArrayElement(items, name, context);
+        const schema = Object.create(Schema.prototype);
+        schema.name = name;
+        schema.primitiveProps = [];
+        schema.arrayProps = [];
+        schema.objectProps = [];
+        schema.enumProps = [];
+        schema.schemaDeps = element.kind === "ref" ? [element.type] : [];
+        schema.enumDeps = element.kind === "enum" ? [element.type] : [];
+        schema.customTypeDeps = [];
+        const rendered = ArraySchemaRenderer.render({
+            name,
+            elementType: element.type,
+            isRef: element.kind === "ref",
+        });
+        schema.interface = rendered.interface;
+        schema.schema = rendered.schema;
+        return schema;
+    }
+    /**
+     * Resolves the element type of an array-root schema. Inline-object items are
+     * already promoted to a `$ref` by `InlineSchemaPromoter`, so by here items is
+     * a `$ref`, an enum, a free-form object (→ `Record<string, unknown>`), or a
+     * primitive. `ArrayProp` is reused for ref/enum/primitive (it also registers
+     * the enum type in the context); the free-form object is special-cased
+     * because `ArrayProp.getType` would degrade it to `string`.
+     */
+    static resolveArrayElement(items, name, context) {
+        if (isReferenceObject(items)) {
+            return { kind: "ref", type: items.$ref.split("/").at(-1) };
+        }
+        if (!items.enum && items.type === "object") {
+            return { kind: "raw", type: "Record<string, unknown>" };
+        }
+        const prop = new ArrayProp({
+            name: "data",
+            schemaObject: { type: "array", items },
+            schemaName: name,
+            required: true,
+            isParam: undefined,
+            isEnum: !!items.enum,
+            isNullable: false,
+            context,
+        });
+        if (items.enum)
+            return { kind: "enum", type: prop.type };
+        return { kind: "raw", type: prop.type };
+    }
     constructor(params) {
         const { name, isEmpty, properties, requireds, fieldConfigs, context } = params;
         this.name = `${isEmpty ? "Empty" : ""}${name}`;

package/dist/core/schema/SchemaRegistry.js

@@ -10,7 +10,13 @@ export class SchemaRegistry {
         if (!componentSchemas)
             return;
         for (const [key, object] of Object.entries(componentSchemas)) {
-            if (isReferenceObject(object) || !object.properties)
+            if (isReferenceObject(object))
+                continue;
+            if (object.type === "array" && object.items) {
+                this.schemas.push(Schema.forArrayRoot({ name: key, items: object.items, context }));
+                continue;
+            }
+            if (!object.properties)
                 continue;
             const properties = object.properties;
             const schema = {

package/dist/props/primitive.property.d.ts

@@ -14,6 +14,7 @@ export declare class PrimitiveProp {
     private readonly example;
     private readonly fallbackExample;
     private readonly defaultValue;
+    private readonly max;
     private get effectiveType();
     /** Non-required fields become nullable (| null) instead of optional (?) */
     private get isEffectivelyNullable();

package/dist/props/primitive.property.js

@@ -13,6 +13,7 @@ export class PrimitiveProp {
     example;
     fallbackExample;
     defaultValue;
+    max;
     get effectiveType() {
         return this.customType ?? this.rawType;
     }
@@ -30,6 +31,7 @@ export class PrimitiveProp {
         this.example = example;
         this.fallbackExample = emptyExample;
         this.defaultValue = schemaObject.default;
+        this.max = schemaObject.maximum;
         const buildedType = customType ?? type;
         const treated = treatPropertyName(name);
         this.name = treated.name;
@@ -113,8 +115,9 @@ export class PrimitiveProp {
             typeParam = `<${this.effectiveType}>`;
         }
         const nullableParam = this.isNullable ? "nullable: true, " : "";
+        const maxParam = this.max !== undefined ? `max: ${this.max}, ` : "";
         return `
-      build${typeParam}({ key: ${keyExpr}, placeholder: ${this.example}, example: ${buildedExample}, required: ${required}, ${nullableParam}${buildedValidator()}})
+      build${typeParam}({ key: ${keyExpr}, placeholder: ${this.example}, example: ${buildedExample}, required: ${required}, ${nullableParam}${maxParam}${buildedValidator()}})
     `;
     }
     thisDot() {

package/dist/runtime/reflector.svelte.ts

@@ -46,6 +46,7 @@ export class BuildedInput<T> {
   required: boolean;
   nullable: boolean;
   placeholder: T;
+  max?: number;
   readonly kind = "builded";
   readonly validator?: ValidatorFn<T>;
 
@@ -55,9 +56,10 @@ export class BuildedInput<T> {
     required: boolean;
     nullable?: boolean;
     placeholder: T;
+    max?: number;
     validator?: ValidatorFn<T>;
   }) {
-    const { example, required, nullable, key, validator, placeholder } = params;
+    const { example, required, nullable, key, validator, placeholder, max } = params;
 
     const initial = key === undefined ? example : key;
 
@@ -67,6 +69,10 @@ export class BuildedInput<T> {
     this.nullable = nullable ?? false;
     this.placeholder = placeholder;
 
+    if (max !== undefined) {
+      this.max = max;
+    }
+
     if (validator) {
       this.validator = validator;
     }
@@ -116,6 +122,7 @@ export function build<T>(params: {
   placeholder: T;
   required: boolean;
   nullable?: boolean;
+  max?: number;
   validator?: ValidatorFn<T>;
 }): BuildedInput<T> {
   return new BuildedInput(params);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "svelte-reflector",
-  "version": "2.1.6",
-  "description": "Reflects zod types from openAPI schemas",
+  "version": "2.1.8",
+  "description": "Reflects types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",