@vaadin/hilla-generator-core 24.7.0-alpha9 → 24.8.0-alpha1

package/Generator.d.ts

@@ -1,13 +1,11 @@
-import type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';
-import File from './File.js';
-import type { PluginConstructor } from './Plugin.js';
+import type LoggerFactory from "@vaadin/hilla-generator-utils/LoggerFactory.js";
+import type { PluginConstructor } from "./Plugin.js";
 export type GeneratorContext = Readonly<{
-    logger: LoggerFactory;
-    outputDir?: string;
+	logger: LoggerFactory
+	outputDir?: string
 }>;
 export default class Generator {
-    #private;
-    constructor(plugins: readonly PluginConstructor[], context: GeneratorContext);
-    process(input: string): Promise<readonly File[]>;
+	#private;
+	constructor(plugins: readonly PluginConstructor[], context: GeneratorContext);
+	process(input: string): Promise<readonly File[]>;
 }
-//# sourceMappingURL=Generator.d.ts.map

package/Generator.js

@@ -1,37 +1,34 @@
 import SwaggerParser from "@apidevtools/swagger-parser";
 import ts from "typescript";
-import File from "./File.js";
 import PluginManager from "./PluginManager.js";
 import ReferenceResolver from "./ReferenceResolver.js";
-class Generator {
-  #logger;
-  #manager;
-  #parser;
-  #outputDir;
-  constructor(plugins, context) {
-    this.#parser = new SwaggerParser();
-    this.#manager = new PluginManager(plugins, new ReferenceResolver(this.#parser), context.logger);
-    this.#logger = context.logger;
-    this.#outputDir = context.outputDir;
-  }
-  async process(input) {
-    this.#logger.global.debug("Processing OpenAPI");
-    const api = await this.#parser.bundle(JSON.parse(input));
-    const storage = {
-      api,
-      apiRefs: this.#parser.$refs,
-      outputDir: this.#outputDir,
-      pluginStorage: /* @__PURE__ */ new Map(),
-      sources: []
-    };
-    this.#logger.global.debug("Executing plugins");
-    await this.#manager.execute(storage);
-    this.#logger.global.debug("Printing files");
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-    return storage.sources.map((file) => new File([printer.printFile(file)], file.fileName));
-  }
+export default class Generator {
+	#logger;
+	#manager;
+	#parser;
+	#outputDir;
+	constructor(plugins, context) {
+		this.#parser = new SwaggerParser();
+		this.#manager = new PluginManager(plugins, new ReferenceResolver(this.#parser), context.logger);
+		this.#logger = context.logger;
+		this.#outputDir = context.outputDir;
+	}
+	async process(input) {
+		this.#logger.global.debug("Processing OpenAPI");
+		const api = await this.#parser.bundle(JSON.parse(input));
+		const storage = {
+			api,
+			apiRefs: this.#parser.$refs,
+			outputDir: this.#outputDir,
+			pluginStorage: new Map(),
+			sources: [],
+			transferTypes: new Map()
+		};
+		this.#logger.global.debug("Executing plugins");
+		await this.#manager.execute(storage);
+		this.#logger.global.debug("Printing files");
+		const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+		return storage.sources.map((file) => new File([printer.printFile(file)], file.fileName));
+	}
 }
-export {
-  Generator as default
-};
-//# sourceMappingURL=Generator.js.map
+//# sourceMappingURL=./Generator.js.map

package/Generator.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/Generator.ts"],
-  "sourcesContent": ["import SwaggerParser from '@apidevtools/swagger-parser';\nimport type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';\nimport type { OpenAPIV3 } from 'openapi-types';\nimport type { ReadonlyDeep } from 'type-fest';\nimport ts from 'typescript';\nimport File from './File.js';\nimport type { PluginConstructor } from './Plugin.js';\nimport PluginManager from './PluginManager.js';\nimport ReferenceResolver from './ReferenceResolver.js';\nimport type SharedStorage from './SharedStorage.js';\n\nexport type GeneratorContext = Readonly<{\n  logger: LoggerFactory;\n  outputDir?: string;\n}>;\n\nexport default class Generator {\n  readonly #logger: LoggerFactory;\n  readonly #manager: PluginManager;\n  readonly #parser: SwaggerParser;\n  readonly #outputDir: string | undefined;\n\n  constructor(plugins: readonly PluginConstructor[], context: GeneratorContext) {\n    this.#parser = new SwaggerParser();\n    this.#manager = new PluginManager(plugins, new ReferenceResolver(this.#parser), context.logger);\n    this.#logger = context.logger;\n    this.#outputDir = context.outputDir;\n  }\n\n  async process(input: string): Promise<readonly File[]> {\n    this.#logger.global.debug('Processing OpenAPI');\n    const api = (await this.#parser.bundle(JSON.parse(input))) as ReadonlyDeep<OpenAPIV3.Document>;\n\n    const storage: SharedStorage = {\n      api,\n      apiRefs: this.#parser.$refs,\n      outputDir: this.#outputDir,\n      pluginStorage: new Map(),\n      sources: [],\n    };\n\n    this.#logger.global.debug('Executing plugins');\n    await this.#manager.execute(storage);\n\n    this.#logger.global.debug('Printing files');\n    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n\n    return storage.sources.map((file) => new File([printer.printFile(file)], file.fileName));\n  }\n}\n"],
-  "mappings": "AAAA,OAAO,mBAAmB;AAI1B,OAAO,QAAQ;AACf,OAAO,UAAU;AAEjB,OAAO,mBAAmB;AAC1B,OAAO,uBAAuB;AAQ9B,MAAO,UAAwB;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,SAAuC,SAA2B;AAC5E,SAAK,UAAU,IAAI,cAAc;AACjC,SAAK,WAAW,IAAI,cAAc,SAAS,IAAI,kBAAkB,KAAK,OAAO,GAAG,QAAQ,MAAM;AAC9F,SAAK,UAAU,QAAQ;AACvB,SAAK,aAAa,QAAQ;AAAA,EAC5B;AAAA,EAEA,MAAM,QAAQ,OAAyC;AACrD,SAAK,QAAQ,OAAO,MAAM,oBAAoB;AAC9C,UAAM,MAAO,MAAM,KAAK,QAAQ,OAAO,KAAK,MAAM,KAAK,CAAC;AAExD,UAAM,UAAyB;AAAA,MAC7B;AAAA,MACA,SAAS,KAAK,QAAQ;AAAA,MACtB,WAAW,KAAK;AAAA,MAChB,eAAe,oBAAI,IAAI;AAAA,MACvB,SAAS,CAAC;AAAA,IACZ;AAEA,SAAK,QAAQ,OAAO,MAAM,mBAAmB;AAC7C,UAAM,KAAK,SAAS,QAAQ,OAAO;AAEnC,SAAK,QAAQ,OAAO,MAAM,gBAAgB;AAC1C,UAAM,UAAU,GAAG,cAAc,EAAE,SAAS,GAAG,YAAY,SAAS,CAAC;AAErE,WAAO,QAAQ,QAAQ,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,QAAQ,UAAU,IAAI,CAAC,GAAG,KAAK,QAAQ,CAAC;AAAA,EACzF;AACF;",
-  "names": []
-}
+{"mappings":"AAAA,OAAO,gDAAiD;AAGxD,OAAO,oBAAqB;AAE5B,OAAO,uCAAwC;AAC/C,OAAO,+CAAgD;AAQvD,eAAe,MAAM,UAAU;CAC7B,AAASA;CACT,AAASC;CACT,AAASC;CACT,AAASC;CAET,YAAYC,SAAuCC,SAA2B;AAC5E,OAAKH,UAAU,IAAI;AACnB,OAAKD,WAAW,IAAI,cAAc,SAAS,IAAI,kBAAkB,KAAKC,UAAU,QAAQ;AACxF,OAAKF,UAAU,QAAQ;AACvB,OAAKG,aAAa,QAAQ;CAC3B;CAED,MAAM,QAAQG,OAAyC;AACrD,OAAKN,QAAQ,OAAO,MAAM,qBAAqB;EAC/C,MAAM,MAAO,MAAM,KAAKE,QAAQ,OAAO,KAAK,MAAM,MAAM,CAAC;EAEzD,MAAMK,UAAyB;GAC7B;GACA,SAAS,KAAKL,QAAQ;GACtB,WAAW,KAAKC;GAChB,eAAe,IAAI;GACnB,SAAS,CAAE;GACX,eAAe,IAAI;EACpB;AAED,OAAKH,QAAQ,OAAO,MAAM,oBAAoB;AAC9C,QAAM,KAAKC,SAAS,QAAQ,QAAQ;AAEpC,OAAKD,QAAQ,OAAO,MAAM,iBAAiB;EAC3C,MAAM,UAAU,GAAG,cAAc,EAAE,SAAS,GAAG,YAAY,SAAU,EAAC;AAEtE,SAAO,QAAQ,QAAQ,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,QAAQ,UAAU,KAAK,AAAC,GAAE,KAAK,UAAU;CACzF;AACF","names":["#logger","#manager","#parser","#outputDir","plugins: readonly PluginConstructor[]","context: GeneratorContext","input: string","storage: SharedStorage"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/generator-core/src/Generator.ts"],"sourcesContent":["import SwaggerParser from '@apidevtools/swagger-parser';\nimport type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';\nimport type { OpenAPIV3 } from 'openapi-types';\nimport ts from 'typescript';\nimport type { PluginConstructor } from './Plugin.js';\nimport PluginManager from './PluginManager.js';\nimport ReferenceResolver from './ReferenceResolver.js';\nimport type { SharedStorage } from './SharedStorage.js';\n\nexport type GeneratorContext = Readonly<{\n  logger: LoggerFactory;\n  outputDir?: string;\n}>;\n\nexport default class Generator {\n  readonly #logger: LoggerFactory;\n  readonly #manager: PluginManager;\n  readonly #parser: SwaggerParser;\n  readonly #outputDir: string | undefined;\n\n  constructor(plugins: readonly PluginConstructor[], context: GeneratorContext) {\n    this.#parser = new SwaggerParser();\n    this.#manager = new PluginManager(plugins, new ReferenceResolver(this.#parser), context.logger);\n    this.#logger = context.logger;\n    this.#outputDir = context.outputDir;\n  }\n\n  async process(input: string): Promise<readonly File[]> {\n    this.#logger.global.debug('Processing OpenAPI');\n    const api = (await this.#parser.bundle(JSON.parse(input))) as OpenAPIV3.Document;\n\n    const storage: SharedStorage = {\n      api,\n      apiRefs: this.#parser.$refs,\n      outputDir: this.#outputDir,\n      pluginStorage: new Map(),\n      sources: [],\n      transferTypes: new Map(),\n    };\n\n    this.#logger.global.debug('Executing plugins');\n    await this.#manager.execute(storage);\n\n    this.#logger.global.debug('Printing files');\n    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n\n    return storage.sources.map((file) => new File([printer.printFile(file)], file.fileName));\n  }\n}\n"],"version":3}

package/Plugin.d.ts

@@ -1,15 +1,14 @@
-import type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';
-import type { Logger } from '@vaadin/hilla-generator-utils/LoggerFactory.js';
-import type { Constructor } from 'type-fest';
-import type ReferenceResolver from './ReferenceResolver.js';
-import type SharedStorage from './SharedStorage.js';
+import type LoggerFactory from "@vaadin/hilla-generator-utils/LoggerFactory.js";
+import type { Logger } from "@vaadin/hilla-generator-utils/LoggerFactory.js";
+import type { Constructor } from "type-fest";
+import type ReferenceResolver from "./ReferenceResolver.js";
+import type { SharedStorage } from "./SharedStorage.js";
 export default abstract class Plugin {
-    readonly resolver: ReferenceResolver;
-    readonly logger: Logger;
-    constructor(resolver: ReferenceResolver, logger: LoggerFactory);
-    get name(): string;
-    abstract get path(): string;
-    abstract execute(storage: SharedStorage): Promise<void>;
+	readonly resolver: ReferenceResolver;
+	readonly logger: Logger;
+	constructor(resolver: ReferenceResolver, logger: LoggerFactory);
+	get name(): string;
+	abstract get path(): string;
+	abstract execute(storage: SharedStorage): Promise<void> | void;
 }
 export type PluginConstructor = Constructor<Plugin, ConstructorParameters<typeof Plugin>>;
-//# sourceMappingURL=Plugin.d.ts.map

package/Plugin.js

@@ -1,15 +1,12 @@
-class Plugin {
-  resolver;
-  logger;
-  constructor(resolver, logger) {
-    this.logger = logger.for(this.constructor.name);
-    this.resolver = resolver;
-  }
-  get name() {
-    return this.constructor.name;
-  }
+export default class Plugin {
+	resolver;
+	logger;
+	constructor(resolver, logger) {
+		this.logger = logger.for(this.constructor.name);
+		this.resolver = resolver;
+	}
+	get name() {
+		return this.constructor.name;
+	}
 }
-export {
-  Plugin as default
-};
-//# sourceMappingURL=Plugin.js.map
+//# sourceMappingURL=./Plugin.js.map

package/Plugin.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/Plugin.ts"],
-  "sourcesContent": ["import type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';\nimport type { Logger } from '@vaadin/hilla-generator-utils/LoggerFactory.js';\nimport type { Constructor } from 'type-fest';\nimport type ReferenceResolver from './ReferenceResolver.js';\nimport type SharedStorage from './SharedStorage.js';\n\nexport default abstract class Plugin {\n  readonly resolver: ReferenceResolver;\n  readonly logger: Logger;\n\n  constructor(resolver: ReferenceResolver, logger: LoggerFactory) {\n    this.logger = logger.for(this.constructor.name);\n    this.resolver = resolver;\n  }\n\n  get name(): string {\n    return this.constructor.name;\n  }\n\n  abstract get path(): string;\n\n  abstract execute(storage: SharedStorage): Promise<void>;\n}\n\nexport type PluginConstructor = Constructor<Plugin, ConstructorParameters<typeof Plugin>>;\n"],
-  "mappings": "AAMA,MAAO,OAA8B;AAAA,EAC1B;AAAA,EACA;AAAA,EAET,YAAY,UAA6B,QAAuB;AAC9D,SAAK,SAAS,OAAO,IAAI,KAAK,YAAY,IAAI;AAC9C,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK,YAAY;AAAA,EAC1B;AAKF;",
-  "names": []
-}
+{"mappings":"AAMA,eAAe,MAAe,OAAO;CACnC,AAAS;CACT,AAAS;CAET,YAAYA,UAA6BC,QAAuB;AAC9D,OAAK,SAAS,OAAO,IAAI,KAAK,YAAY,KAAK;AAC/C,OAAK,WAAW;CACjB;CAED,IAAI,OAAe;AACjB,SAAO,KAAK,YAAY;CACzB;AAKF","names":["resolver: ReferenceResolver","logger: LoggerFactory"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/generator-core/src/Plugin.ts"],"sourcesContent":["import type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';\nimport type { Logger } from '@vaadin/hilla-generator-utils/LoggerFactory.js';\nimport type { Constructor } from 'type-fest';\nimport type ReferenceResolver from './ReferenceResolver.js';\nimport type { SharedStorage } from './SharedStorage.js';\n\nexport default abstract class Plugin {\n  readonly resolver: ReferenceResolver;\n  readonly logger: Logger;\n\n  constructor(resolver: ReferenceResolver, logger: LoggerFactory) {\n    this.logger = logger.for(this.constructor.name);\n    this.resolver = resolver;\n  }\n\n  get name(): string {\n    return this.constructor.name;\n  }\n\n  abstract get path(): string;\n\n  abstract execute(storage: SharedStorage): Promise<void> | void;\n}\n\nexport type PluginConstructor = Constructor<Plugin, ConstructorParameters<typeof Plugin>>;\n"],"version":3}

package/PluginManager.d.ts

@@ -1,10 +1,9 @@
-import type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';
-import type { PluginConstructor } from './Plugin.js';
-import type ReferenceResolver from './ReferenceResolver.js';
-import type SharedStorage from './SharedStorage.js';
+import type LoggerFactory from "@vaadin/hilla-generator-utils/LoggerFactory.js";
+import type { PluginConstructor } from "./Plugin.js";
+import type ReferenceResolver from "./ReferenceResolver.js";
+import type { SharedStorage } from "./SharedStorage.js";
 export default class PluginManager {
-    #private;
-    constructor(plugins: readonly PluginConstructor[], resolver: ReferenceResolver, logger: LoggerFactory);
-    execute(storage: SharedStorage): Promise<void>;
+	#private;
+	constructor(plugins: readonly PluginConstructor[], resolver: ReferenceResolver, logger: LoggerFactory);
+	execute(storage: SharedStorage): Promise<void>;
 }
-//# sourceMappingURL=PluginManager.d.ts.map

package/PluginManager.js

@@ -1,30 +1,31 @@
-class PluginManager {
-  #plugins;
-  constructor(plugins, resolver, logger) {
-    const standardPlugins = [
-      "BackbonePlugin",
-      "ClientPlugin",
-      "BarrelPlugin",
-      "ModelPlugin",
-      "PushPlugin",
-      "SubTypesPlugin",
-      "SignalsPlugin"
-    ];
-    const customPlugins = plugins.filter((p) => !standardPlugins.includes(p.name));
-    if (customPlugins.length > 0) {
-      logger.global.info(`Plugins: ${plugins.map(({ name }) => name).join(", ")}`);
-    }
-    this.#plugins = plugins.map((PluginClass) => new PluginClass(resolver, logger));
-  }
-  async execute(storage) {
-    for (const plugin of this.#plugins) {
-      const { name, path } = plugin;
-      plugin.logger.debug({ plugin: { name, path } }, `Executing plugin '${plugin.name}'`);
-      await plugin.execute(storage);
-    }
-  }
+export default class PluginManager {
+	#plugins;
+	constructor(plugins, resolver, logger) {
+		const standardPlugins = [
+			"TransferTypesPlugin",
+			"BackbonePlugin",
+			"ClientPlugin",
+			"BarrelPlugin",
+			"ModelPlugin",
+			"PushPlugin",
+			"SubTypesPlugin",
+			"SignalsPlugin"
+		];
+		const customPlugins = plugins.filter((p) => !standardPlugins.includes(p.name));
+		if (customPlugins.length > 0) {
+			logger.global.info(`Plugins: ${plugins.map(({ name }) => name).join(", ")}`);
+		}
+		this.#plugins = plugins.map((PluginClass) => new PluginClass(resolver, logger));
+	}
+	async execute(storage) {
+		for (const plugin of this.#plugins) {
+			const { name, path } = plugin;
+			plugin.logger.debug({ plugin: {
+				name,
+				path
+			} }, `Executing plugin '${plugin.name}'`);
+			await plugin.execute(storage);
+		}
+	}
 }
-export {
-  PluginManager as default
-};
-//# sourceMappingURL=PluginManager.js.map
+//# sourceMappingURL=./PluginManager.js.map

package/PluginManager.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/PluginManager.ts"],
-  "sourcesContent": ["import type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';\nimport type Plugin from './Plugin.js';\nimport type { PluginConstructor } from './Plugin.js';\nimport type ReferenceResolver from './ReferenceResolver.js';\nimport type SharedStorage from './SharedStorage.js';\n\nexport default class PluginManager {\n  readonly #plugins: Plugin[];\n\n  constructor(plugins: readonly PluginConstructor[], resolver: ReferenceResolver, logger: LoggerFactory) {\n    const standardPlugins = [\n      'BackbonePlugin',\n      'ClientPlugin',\n      'BarrelPlugin',\n      'ModelPlugin',\n      'PushPlugin',\n      'SubTypesPlugin',\n      'SignalsPlugin',\n    ];\n    const customPlugins = plugins.filter((p) => !standardPlugins.includes(p.name));\n    if (customPlugins.length > 0) {\n      logger.global.info(`Plugins: ${plugins.map(({ name }) => name).join(', ')}`);\n    }\n    this.#plugins = plugins.map((PluginClass) => new PluginClass(resolver, logger));\n  }\n\n  async execute(storage: SharedStorage): Promise<void> {\n    // We need to run plugins sequentially\n    for (const plugin of this.#plugins) {\n      const { name, path } = plugin;\n      plugin.logger.debug({ plugin: { name, path } }, `Executing plugin '${plugin.name}'`);\n      // eslint-disable-next-line no-await-in-loop\n      await plugin.execute(storage);\n    }\n  }\n}\n"],
-  "mappings": "AAMA,MAAO,cAA4B;AAAA,EACxB;AAAA,EAET,YAAY,SAAuC,UAA6B,QAAuB;AACrG,UAAM,kBAAkB;AAAA,MACtB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,UAAM,gBAAgB,QAAQ,OAAO,CAAC,MAAM,CAAC,gBAAgB,SAAS,EAAE,IAAI,CAAC;AAC7E,QAAI,cAAc,SAAS,GAAG;AAC5B,aAAO,OAAO,KAAK,YAAY,QAAQ,IAAI,CAAC,EAAE,KAAK,MAAM,IAAI,EAAE,KAAK,IAAI,CAAC,EAAE;AAAA,IAC7E;AACA,SAAK,WAAW,QAAQ,IAAI,CAAC,gBAAgB,IAAI,YAAY,UAAU,MAAM,CAAC;AAAA,EAChF;AAAA,EAEA,MAAM,QAAQ,SAAuC;AAEnD,eAAW,UAAU,KAAK,UAAU;AAClC,YAAM,EAAE,MAAM,KAAK,IAAI;AACvB,aAAO,OAAO,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,EAAE,GAAG,qBAAqB,OAAO,IAAI,GAAG;AAEnF,YAAM,OAAO,QAAQ,OAAO;AAAA,IAC9B;AAAA,EACF;AACF;",
-  "names": []
-}
+{"mappings":"AAMA,eAAe,MAAM,cAAc;CACjC,AAASA;CAET,YAAYC,SAAuCC,UAA6BC,QAAuB;EACrG,MAAM,kBAAkB;GACtB;GACA;GACA;GACA;GACA;GACA;GACA;GACA;EACD;EACD,MAAM,gBAAgB,QAAQ,OAAO,CAAC,OAAO,gBAAgB,SAAS,EAAE,KAAK,CAAC;AAC9E,MAAI,cAAc,SAAS,GAAG;AAC5B,UAAO,OAAO,MAAM,WAAW,QAAQ,IAAI,CAAC,EAAE,MAAM,KAAK,KAAK,CAAC,KAAK,KAAK,CAAC,EAAE;EAC7E;AACD,OAAKH,WAAW,QAAQ,IAAI,CAAC,gBAAgB,IAAI,YAAY,UAAU,QAAQ;CAChF;CAED,MAAM,QAAQI,SAAuC;AAEnD,OAAK,MAAM,UAAU,KAAKJ,UAAU;GAClC,MAAM,EAAE,MAAM,MAAM,GAAG;AACvB,UAAO,OAAO,MAAM,EAAE,QAAQ;IAAE;IAAM;GAAM,EAAE,IAAG,oBAAoB,OAAO,KAAK,GAAG;AAEpF,SAAM,OAAO,QAAQ,QAAQ;EAC9B;CACF;AACF","names":["#plugins","plugins: readonly PluginConstructor[]","resolver: ReferenceResolver","logger: LoggerFactory","storage: SharedStorage"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/generator-core/src/PluginManager.ts"],"sourcesContent":["import type LoggerFactory from '@vaadin/hilla-generator-utils/LoggerFactory.js';\nimport type Plugin from './Plugin.js';\nimport type { PluginConstructor } from './Plugin.js';\nimport type ReferenceResolver from './ReferenceResolver.js';\nimport type { SharedStorage } from './SharedStorage.js';\n\nexport default class PluginManager {\n  readonly #plugins: Plugin[];\n\n  constructor(plugins: readonly PluginConstructor[], resolver: ReferenceResolver, logger: LoggerFactory) {\n    const standardPlugins = [\n      'TransferTypesPlugin',\n      'BackbonePlugin',\n      'ClientPlugin',\n      'BarrelPlugin',\n      'ModelPlugin',\n      'PushPlugin',\n      'SubTypesPlugin',\n      'SignalsPlugin',\n    ];\n    const customPlugins = plugins.filter((p) => !standardPlugins.includes(p.name));\n    if (customPlugins.length > 0) {\n      logger.global.info(`Plugins: ${plugins.map(({ name }) => name).join(', ')}`);\n    }\n    this.#plugins = plugins.map((PluginClass) => new PluginClass(resolver, logger));\n  }\n\n  async execute(storage: SharedStorage): Promise<void> {\n    // We need to run plugins sequentially\n    for (const plugin of this.#plugins) {\n      const { name, path } = plugin;\n      plugin.logger.debug({ plugin: { name, path } }, `Executing plugin '${plugin.name}'`);\n      // eslint-disable-next-line no-await-in-loop\n      await plugin.execute(storage);\n    }\n  }\n}\n"],"version":3}

package/ReferenceResolver.d.ts

@@ -1,9 +1,7 @@
-import type SwaggerParser from '@apidevtools/swagger-parser';
-import type { OpenAPIV3 } from 'openapi-types';
-import type { ReadonlyDeep } from 'type-fest';
+import type SwaggerParser from "@apidevtools/swagger-parser";
+import type { OpenAPIV3 } from "openapi-types";
 export default class ReferenceResolver {
-    #private;
-    constructor(parser: SwaggerParser);
-    resolve<T extends ReadonlyDeep<object>>(obj: ReadonlyDeep<OpenAPIV3.ReferenceObject> | T): T;
+	#private;
+	constructor(parser: SwaggerParser);
+	resolve<T extends object>(obj: OpenAPIV3.ReferenceObject | T): T;
 }
-//# sourceMappingURL=ReferenceResolver.d.ts.map

package/ReferenceResolver.js

@@ -1,14 +1,10 @@
-class ReferenceResolver {
-  #parser;
-  constructor(parser) {
-    this.#parser = parser;
-  }
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  resolve(obj) {
-    return "$ref" in obj ? this.#parser.$refs.get(obj.$ref) : obj;
-  }
+export default class ReferenceResolver {
+	#parser;
+	constructor(parser) {
+		this.#parser = parser;
+	}
+	resolve(obj) {
+		return "$ref" in obj ? this.#parser.$refs.get(obj.$ref) : obj;
+	}
 }
-export {
-  ReferenceResolver as default
-};
-//# sourceMappingURL=ReferenceResolver.js.map
+//# sourceMappingURL=./ReferenceResolver.js.map

package/ReferenceResolver.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/ReferenceResolver.ts"],
-  "sourcesContent": ["import type SwaggerParser from '@apidevtools/swagger-parser';\nimport type { OpenAPIV3 } from 'openapi-types';\nimport type { ReadonlyDeep } from 'type-fest';\n\nexport default class ReferenceResolver {\n  readonly #parser: SwaggerParser;\n\n  constructor(parser: SwaggerParser) {\n    this.#parser = parser;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  resolve<T extends ReadonlyDeep<object>>(obj: ReadonlyDeep<OpenAPIV3.ReferenceObject> | T): T {\n    return '$ref' in obj ? this.#parser.$refs.get(obj.$ref) : obj;\n  }\n}\n"],
-  "mappings": "AAIA,MAAO,kBAAgC;AAAA,EAC5B;AAAA,EAET,YAAY,QAAuB;AACjC,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA,EAGA,QAAwC,KAAqD;AAC3F,WAAO,UAAU,MAAM,KAAK,QAAQ,MAAM,IAAI,IAAI,IAAI,IAAI;AAAA,EAC5D;AACF;",
-  "names": []
-}
+{"mappings":"AAGA,eAAe,MAAM,kBAAkB;CACrC,AAASA;CAET,YAAYC,QAAuB;AACjC,OAAKD,UAAU;CAChB;CAED,QAA0BE,KAAuC;AAC/D,SAAO,UAAU,MAAM,KAAKF,QAAQ,MAAM,IAAI,IAAI,KAAK,GAAG;CAC3D;AACF","names":["#parser","parser: SwaggerParser","obj: OpenAPIV3.ReferenceObject | T"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/generator-core/src/ReferenceResolver.ts"],"sourcesContent":["import type SwaggerParser from '@apidevtools/swagger-parser';\nimport type { OpenAPIV3 } from 'openapi-types';\n\nexport default class ReferenceResolver {\n  readonly #parser: SwaggerParser;\n\n  constructor(parser: SwaggerParser) {\n    this.#parser = parser;\n  }\n\n  resolve<T extends object>(obj: OpenAPIV3.ReferenceObject | T): T {\n    return '$ref' in obj ? this.#parser.$refs.get(obj.$ref) : obj;\n  }\n}\n"],"version":3}

package/Schema.d.ts

@@ -1,37 +1,39 @@
-import type { OpenAPIV3 } from 'openapi-types';
-import type { ReadonlyDeep } from 'type-fest';
-import { type Nullified } from './utils.js';
-export type ReferenceSchema = ReadonlyDeep<OpenAPIV3.ReferenceObject>;
-export type ArraySchema = ReadonlyDeep<OpenAPIV3.ArraySchemaObject>;
-export type NonArraySchema = ReadonlyDeep<OpenAPIV3.NonArraySchemaObject>;
+import type { OpenAPIV3 } from "openapi-types";
+export type Nullified<
+	T,
+	K extends keyof T
+> = T & Record<K, undefined>;
+export type ReferenceSchema = OpenAPIV3.ReferenceObject;
+export type ArraySchema = OpenAPIV3.ArraySchemaObject;
+export type NonArraySchema = OpenAPIV3.NonArraySchemaObject;
 export type RegularSchema = ArraySchema | NonArraySchema;
-export type NullableSchema = Readonly<Required<Pick<RegularSchema, 'nullable'>>> & RegularSchema;
-export type AnyOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'anyOf'>>> & RegularSchema;
-export type AllOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'allOf'>>> & RegularSchema;
-export type OneOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'oneOf'>>> & RegularSchema;
-export type NotRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'not'>>> & RegularSchema;
+export type NullableSchema = Readonly<Required<Pick<RegularSchema, "nullable">>> & RegularSchema;
+export type AnyOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, "anyOf">>> & RegularSchema;
+export type AllOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, "allOf">>> & RegularSchema;
+export type OneOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, "oneOf">>> & RegularSchema;
+export type NotRuleComposedSchema = Readonly<Required<Pick<RegularSchema, "not">>> & RegularSchema;
 export type ComposedSchema = AllOfRuleComposedSchema | AnyOfRuleComposedSchema | NotRuleComposedSchema | OneOfRuleComposedSchema;
-export type NonComposedRegularSchema = Readonly<Nullified<RegularSchema, 'allOf' | 'anyOf' | 'oneOf'>> & RegularSchema;
+export type NonComposedRegularSchema = Readonly<Nullified<RegularSchema, "allOf" | "anyOf" | "oneOf">> & RegularSchema;
 export type NonComposedSchema = NonComposedRegularSchema | ReferenceSchema;
 export type BooleanSchema = NonComposedRegularSchema & Readonly<{
-    type: 'boolean';
+	type: "boolean"
 }>;
 export type IntegerSchema = NonComposedRegularSchema & Readonly<{
-    type: 'integer';
+	type: "integer"
 }>;
 export type NumberSchema = NonComposedRegularSchema & Readonly<{
-    type: 'number';
+	type: "number"
 }>;
 export type ObjectSchema = NonComposedRegularSchema & Readonly<{
-    type: 'object';
+	type: "object"
 }>;
 export type StringSchema = NonComposedRegularSchema & Readonly<{
-    type: 'string';
+	type: "string"
 }>;
-export type EnumSchema = Readonly<Required<Pick<StringSchema, 'enum'>>> & StringSchema;
-export type EmptyObjectSchema = ObjectSchema & Readonly<Nullified<ObjectSchema, 'properties'>>;
-export type NonEmptyObjectSchema = ObjectSchema & Readonly<Required<Pick<ObjectSchema, 'properties'>>>;
-export type MapSchema = EmptyObjectSchema & Readonly<Required<Pick<ObjectSchema, 'additionalProperties'>>>;
+export type EnumSchema = Readonly<Required<Pick<StringSchema, "enum">>> & StringSchema;
+export type EmptyObjectSchema = ObjectSchema & Readonly<Nullified<ObjectSchema, "properties">>;
+export type NonEmptyObjectSchema = ObjectSchema & Readonly<Required<Pick<ObjectSchema, "properties">>>;
+export type MapSchema = EmptyObjectSchema & Readonly<Required<Pick<ObjectSchema, "additionalProperties">>>;
 export type Schema = ReferenceSchema | RegularSchema;
 export declare function isReferenceSchema(schema: Schema): schema is ReferenceSchema;
 export declare function isAnyOfRuleComposedSchema(schema: Schema): schema is AnyOfRuleComposedSchema;
@@ -52,7 +54,9 @@ export declare function isStringSchema(schema: Schema): schema is StringSchema;
 export declare function isEnumSchema(schema: Schema): schema is EnumSchema;
 export declare function isEmptyObject(schema: Schema): schema is EmptyObjectSchema;
 export declare function isMapSchema(schema: Schema): schema is MapSchema;
+export declare function simplifyFullyQualifiedName(name: string): string;
 export declare function convertReferenceSchemaToSpecifier({ $ref }: ReferenceSchema): string;
-export declare function convertReferenceSchemaToPath({ $ref }: ReferenceSchema): string;
-export declare function resolveReference(schemas: ReadonlyDeep<OpenAPIV3.ComponentsObject>['schemas'], { $ref }: ReferenceSchema): Schema | undefined;
-//# sourceMappingURL=Schema.d.ts.map
+export declare function convertReferenceSchemaToFullyQualifiedName({ $ref }: ReferenceSchema): string;
+export declare function convertFullyQualifiedNameToRelativePath(name: string): string;
+export declare function convertReferenceSchemaToPath(schema: ReferenceSchema): string;
+export declare function resolveReference(schemas: OpenAPIV3.ComponentsObject["schemas"], { $ref }: ReferenceSchema): Schema | undefined;

package/Schema.js

@@ -1,109 +1,93 @@
-import { convertFullyQualifiedNameToRelativePath, simplifyFullyQualifiedName } from "./utils.js";
-function isReferenceSchema(schema) {
-  return "$ref" in schema;
+export function isReferenceSchema(schema) {
+	return "$ref" in schema;
 }
-function isAnyOfRuleComposedSchema(schema) {
-  return "anyOf" in schema;
+export function isAnyOfRuleComposedSchema(schema) {
+	return "anyOf" in schema;
 }
-function isAllOfRuleComposedSchema(schema) {
-  return "allOf" in schema;
+export function isAllOfRuleComposedSchema(schema) {
+	return "allOf" in schema;
 }
-function isOneOfRuleComposedSchema(schema) {
-  return "oneOf" in schema;
+export function isOneOfRuleComposedSchema(schema) {
+	return "oneOf" in schema;
 }
-function isNotRuleComposedSchema(schema) {
-  return "not" in schema;
+export function isNotRuleComposedSchema(schema) {
+	return "not" in schema;
 }
-function isComposedSchema(schema) {
-  return isAnyOfRuleComposedSchema(schema) || isAllOfRuleComposedSchema(schema) || isOneOfRuleComposedSchema(schema) || isNotRuleComposedSchema(schema);
+export function isComposedSchema(schema) {
+	return isAnyOfRuleComposedSchema(schema) || isAllOfRuleComposedSchema(schema) || isOneOfRuleComposedSchema(schema) || isNotRuleComposedSchema(schema);
 }
-function isNonComposedSchema(schema) {
-  return !isComposedSchema(schema);
+export function isNonComposedSchema(schema) {
+	return !isComposedSchema(schema);
 }
-function isNonComposedRegularSchema(schema) {
-  return isNonComposedSchema(schema) && !isReferenceSchema(schema);
+export function isNonComposedRegularSchema(schema) {
+	return isNonComposedSchema(schema) && !isReferenceSchema(schema);
 }
-function isNullableSchema(schema) {
-  return !isReferenceSchema(schema) && !!schema.nullable;
+export function isNullableSchema(schema) {
+	return !isReferenceSchema(schema) && !!schema.nullable;
 }
-function decomposeSchema(schema) {
-  if (isAnyOfRuleComposedSchema(schema)) {
-    return schema.anyOf;
-  }
-  if (isAllOfRuleComposedSchema(schema)) {
-    return schema.allOf;
-  }
-  if (isOneOfRuleComposedSchema(schema)) {
-    return schema.oneOf;
-  }
-  return [schema.not];
+export function decomposeSchema(schema) {
+	if (isAnyOfRuleComposedSchema(schema)) {
+		return schema.anyOf;
+	}
+	if (isAllOfRuleComposedSchema(schema)) {
+		return schema.allOf;
+	}
+	if (isOneOfRuleComposedSchema(schema)) {
+		return schema.oneOf;
+	}
+	return [schema.not];
 }
-function isArraySchema(schema) {
-  return isNonComposedRegularSchema(schema) && schema.type === "array";
+export function isArraySchema(schema) {
+	return isNonComposedRegularSchema(schema) && schema.type === "array";
 }
-function isBooleanSchema(schema) {
-  return isNonComposedRegularSchema(schema) && schema.type === "boolean";
+export function isBooleanSchema(schema) {
+	return isNonComposedRegularSchema(schema) && schema.type === "boolean";
 }
-function isIntegerSchema(schema) {
-  return isNonComposedRegularSchema(schema) && schema.type === "integer";
+export function isIntegerSchema(schema) {
+	return isNonComposedRegularSchema(schema) && schema.type === "integer";
 }
-function isNumberSchema(schema) {
-  return isNonComposedRegularSchema(schema) && schema.type === "number";
+export function isNumberSchema(schema) {
+	return isNonComposedRegularSchema(schema) && schema.type === "number";
 }
-function isObjectSchema(schema) {
-  return isNonComposedRegularSchema(schema) && schema.type === "object";
+export function isObjectSchema(schema) {
+	return isNonComposedRegularSchema(schema) && schema.type === "object";
 }
-function isStringSchema(schema) {
-  return isNonComposedRegularSchema(schema) && schema.type === "string";
+export function isStringSchema(schema) {
+	return isNonComposedRegularSchema(schema) && schema.type === "string";
 }
-function isEnumSchema(schema) {
-  return isStringSchema(schema) && !!schema.enum;
+export function isEnumSchema(schema) {
+	return isStringSchema(schema) && !!schema.enum;
 }
-function isEmptyObject(schema) {
-  return isObjectSchema(schema) && !schema.properties;
+export function isEmptyObject(schema) {
+	return isObjectSchema(schema) && !schema.properties;
 }
-function isMapSchema(schema) {
-  return isEmptyObject(schema) && !!schema.additionalProperties;
+export function isMapSchema(schema) {
+	return isEmptyObject(schema) && !!schema.additionalProperties;
 }
-function convertReferenceSchemaToSpecifier({ $ref }) {
-  return simplifyFullyQualifiedName($ref);
+export function simplifyFullyQualifiedName(name) {
+	return name.substring(name.lastIndexOf(name.includes("$") ? "$" : ".") + 1, name.length);
+}
+export function convertReferenceSchemaToSpecifier({ $ref }) {
+	return simplifyFullyQualifiedName($ref);
 }
 const COMPONENTS_SCHEMAS_REF_LENGTH = "#/components/schemas/".length;
-function convertReferenceSchemaToPath({ $ref }) {
-  return convertFullyQualifiedNameToRelativePath($ref.substring(COMPONENTS_SCHEMAS_REF_LENGTH));
-}
-function resolveReference(schemas, { $ref }) {
-  if (schemas) {
-    for (const [name, schema] of Object.entries(schemas)) {
-      if ($ref.includes(name)) {
-        return schema;
-      }
-    }
-  }
-  return void 0;
-}
-export {
-  convertReferenceSchemaToPath,
-  convertReferenceSchemaToSpecifier,
-  decomposeSchema,
-  isAllOfRuleComposedSchema,
-  isAnyOfRuleComposedSchema,
-  isArraySchema,
-  isBooleanSchema,
-  isComposedSchema,
-  isEmptyObject,
-  isEnumSchema,
-  isIntegerSchema,
-  isMapSchema,
-  isNonComposedRegularSchema,
-  isNonComposedSchema,
-  isNotRuleComposedSchema,
-  isNullableSchema,
-  isNumberSchema,
-  isObjectSchema,
-  isOneOfRuleComposedSchema,
-  isReferenceSchema,
-  isStringSchema,
-  resolveReference
-};
-//# sourceMappingURL=Schema.js.map
+export function convertReferenceSchemaToFullyQualifiedName({ $ref }) {
+	return $ref.substring(COMPONENTS_SCHEMAS_REF_LENGTH);
+}
+export function convertFullyQualifiedNameToRelativePath(name) {
+	return name.replace(/[$.]/gu, "/");
+}
+export function convertReferenceSchemaToPath(schema) {
+	return convertFullyQualifiedNameToRelativePath(convertReferenceSchemaToFullyQualifiedName(schema));
+}
+export function resolveReference(schemas, { $ref }) {
+	if (schemas) {
+		for (const [name, schema] of Object.entries(schemas)) {
+			if ($ref.includes(name)) {
+				return schema;
+			}
+		}
+	}
+	return undefined;
+}
+//# sourceMappingURL=./Schema.js.map

package/Schema.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["src/Schema.ts"],
-  "sourcesContent": ["import type { OpenAPIV3 } from 'openapi-types';\nimport type { ReadonlyDeep } from 'type-fest';\nimport { convertFullyQualifiedNameToRelativePath, simplifyFullyQualifiedName, type Nullified } from './utils.js';\n\nexport type ReferenceSchema = ReadonlyDeep<OpenAPIV3.ReferenceObject>;\nexport type ArraySchema = ReadonlyDeep<OpenAPIV3.ArraySchemaObject>;\nexport type NonArraySchema = ReadonlyDeep<OpenAPIV3.NonArraySchemaObject>;\nexport type RegularSchema = ArraySchema | NonArraySchema;\n\nexport type NullableSchema = Readonly<Required<Pick<RegularSchema, 'nullable'>>> & RegularSchema;\n\nexport type AnyOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'anyOf'>>> & RegularSchema;\nexport type AllOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'allOf'>>> & RegularSchema;\nexport type OneOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'oneOf'>>> & RegularSchema;\nexport type NotRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'not'>>> & RegularSchema;\nexport type ComposedSchema =\n  | AllOfRuleComposedSchema\n  | AnyOfRuleComposedSchema\n  | NotRuleComposedSchema\n  | OneOfRuleComposedSchema;\n\nexport type NonComposedRegularSchema = Readonly<Nullified<RegularSchema, 'allOf' | 'anyOf' | 'oneOf'>> & RegularSchema;\nexport type NonComposedSchema = NonComposedRegularSchema | ReferenceSchema;\n\nexport type BooleanSchema = NonComposedRegularSchema & Readonly<{ type: 'boolean' }>;\nexport type IntegerSchema = NonComposedRegularSchema & Readonly<{ type: 'integer' }>;\nexport type NumberSchema = NonComposedRegularSchema & Readonly<{ type: 'number' }>;\nexport type ObjectSchema = NonComposedRegularSchema & Readonly<{ type: 'object' }>;\nexport type StringSchema = NonComposedRegularSchema & Readonly<{ type: 'string' }>;\n\nexport type EnumSchema = Readonly<Required<Pick<StringSchema, 'enum'>>> & StringSchema;\nexport type EmptyObjectSchema = ObjectSchema & Readonly<Nullified<ObjectSchema, 'properties'>>;\nexport type NonEmptyObjectSchema = ObjectSchema & Readonly<Required<Pick<ObjectSchema, 'properties'>>>;\nexport type MapSchema = EmptyObjectSchema & Readonly<Required<Pick<ObjectSchema, 'additionalProperties'>>>;\n\nexport type Schema = ReferenceSchema | RegularSchema;\n\nexport function isReferenceSchema(schema: Schema): schema is ReferenceSchema {\n  return '$ref' in schema;\n}\n\nexport function isAnyOfRuleComposedSchema(schema: Schema): schema is AnyOfRuleComposedSchema {\n  return 'anyOf' in schema;\n}\n\nexport function isAllOfRuleComposedSchema(schema: Schema): schema is AllOfRuleComposedSchema {\n  return 'allOf' in schema;\n}\n\nexport function isOneOfRuleComposedSchema(schema: Schema): schema is OneOfRuleComposedSchema {\n  return 'oneOf' in schema;\n}\n\nexport function isNotRuleComposedSchema(schema: Schema): schema is NotRuleComposedSchema {\n  return 'not' in schema;\n}\n\nexport function isComposedSchema(schema: Schema): schema is ComposedSchema {\n  return (\n    isAnyOfRuleComposedSchema(schema) ||\n    isAllOfRuleComposedSchema(schema) ||\n    isOneOfRuleComposedSchema(schema) ||\n    isNotRuleComposedSchema(schema)\n  );\n}\n\nexport function isNonComposedSchema(schema: Schema): schema is NonComposedSchema {\n  return !isComposedSchema(schema);\n}\n\nexport function isNonComposedRegularSchema(schema: Schema): schema is NonComposedRegularSchema {\n  return isNonComposedSchema(schema) && !isReferenceSchema(schema);\n}\n\nexport function isNullableSchema(schema: Schema): schema is NullableSchema {\n  return !isReferenceSchema(schema) && !!schema.nullable;\n}\n\nexport function decomposeSchema(schema: ComposedSchema): readonly Schema[] {\n  if (isAnyOfRuleComposedSchema(schema)) {\n    return schema.anyOf;\n  }\n\n  if (isAllOfRuleComposedSchema(schema)) {\n    return schema.allOf;\n  }\n\n  if (isOneOfRuleComposedSchema(schema)) {\n    return schema.oneOf;\n  }\n\n  return [schema.not];\n}\n\nexport function isArraySchema(schema: Schema): schema is ArraySchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'array';\n}\n\nexport function isBooleanSchema(schema: Schema): schema is BooleanSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'boolean';\n}\n\nexport function isIntegerSchema(schema: Schema): schema is IntegerSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'integer';\n}\n\nexport function isNumberSchema(schema: Schema): schema is NumberSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'number';\n}\n\nexport function isObjectSchema(schema: Schema): schema is ObjectSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'object';\n}\n\nexport function isStringSchema(schema: Schema): schema is StringSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'string';\n}\n\nexport function isEnumSchema(schema: Schema): schema is EnumSchema {\n  return isStringSchema(schema) && !!schema.enum;\n}\n\nexport function isEmptyObject(schema: Schema): schema is EmptyObjectSchema {\n  return isObjectSchema(schema) && !schema.properties;\n}\n\nexport function isMapSchema(schema: Schema): schema is MapSchema {\n  return isEmptyObject(schema) && !!schema.additionalProperties;\n}\n\nexport function convertReferenceSchemaToSpecifier({ $ref }: ReferenceSchema): string {\n  return simplifyFullyQualifiedName($ref);\n}\n\nconst COMPONENTS_SCHEMAS_REF_LENGTH = '#/components/schemas/'.length;\n\nexport function convertReferenceSchemaToPath({ $ref }: ReferenceSchema): string {\n  return convertFullyQualifiedNameToRelativePath($ref.substring(COMPONENTS_SCHEMAS_REF_LENGTH));\n}\n\nexport function resolveReference(\n  schemas: ReadonlyDeep<OpenAPIV3.ComponentsObject>['schemas'],\n  { $ref }: ReferenceSchema,\n): Schema | undefined {\n  if (schemas) {\n    for (const [name, schema] of Object.entries(schemas)) {\n      if ($ref.includes(name)) {\n        return schema;\n      }\n    }\n  }\n\n  return undefined;\n}\n"],
-  "mappings": "AAEA,SAAS,yCAAyC,kCAAkD;AAmC7F,SAAS,kBAAkB,QAA2C;AAC3E,SAAO,UAAU;AACnB;AAEO,SAAS,0BAA0B,QAAmD;AAC3F,SAAO,WAAW;AACpB;AAEO,SAAS,0BAA0B,QAAmD;AAC3F,SAAO,WAAW;AACpB;AAEO,SAAS,0BAA0B,QAAmD;AAC3F,SAAO,WAAW;AACpB;AAEO,SAAS,wBAAwB,QAAiD;AACvF,SAAO,SAAS;AAClB;AAEO,SAAS,iBAAiB,QAA0C;AACzE,SACE,0BAA0B,MAAM,KAChC,0BAA0B,MAAM,KAChC,0BAA0B,MAAM,KAChC,wBAAwB,MAAM;AAElC;AAEO,SAAS,oBAAoB,QAA6C;AAC/E,SAAO,CAAC,iBAAiB,MAAM;AACjC;AAEO,SAAS,2BAA2B,QAAoD;AAC7F,SAAO,oBAAoB,MAAM,KAAK,CAAC,kBAAkB,MAAM;AACjE;AAEO,SAAS,iBAAiB,QAA0C;AACzE,SAAO,CAAC,kBAAkB,MAAM,KAAK,CAAC,CAAC,OAAO;AAChD;AAEO,SAAS,gBAAgB,QAA2C;AACzE,MAAI,0BAA0B,MAAM,GAAG;AACrC,WAAO,OAAO;AAAA,EAChB;AAEA,MAAI,0BAA0B,MAAM,GAAG;AACrC,WAAO,OAAO;AAAA,EAChB;AAEA,MAAI,0BAA0B,MAAM,GAAG;AACrC,WAAO,OAAO;AAAA,EAChB;AAEA,SAAO,CAAC,OAAO,GAAG;AACpB;AAEO,SAAS,cAAc,QAAuC;AACnE,SAAO,2BAA2B,MAAM,KAAK,OAAO,SAAS;AAC/D;AAEO,SAAS,gBAAgB,QAAyC;AACvE,SAAO,2BAA2B,MAAM,KAAK,OAAO,SAAS;AAC/D;AAEO,SAAS,gBAAgB,QAAyC;AACvE,SAAO,2BAA2B,MAAM,KAAK,OAAO,SAAS;AAC/D;AAEO,SAAS,eAAe,QAAwC;AACrE,SAAO,2BAA2B,MAAM,KAAK,OAAO,SAAS;AAC/D;AAEO,SAAS,eAAe,QAAwC;AACrE,SAAO,2BAA2B,MAAM,KAAK,OAAO,SAAS;AAC/D;AAEO,SAAS,eAAe,QAAwC;AACrE,SAAO,2BAA2B,MAAM,KAAK,OAAO,SAAS;AAC/D;AAEO,SAAS,aAAa,QAAsC;AACjE,SAAO,eAAe,MAAM,KAAK,CAAC,CAAC,OAAO;AAC5C;AAEO,SAAS,cAAc,QAA6C;AACzE,SAAO,eAAe,MAAM,KAAK,CAAC,OAAO;AAC3C;AAEO,SAAS,YAAY,QAAqC;AAC/D,SAAO,cAAc,MAAM,KAAK,CAAC,CAAC,OAAO;AAC3C;AAEO,SAAS,kCAAkC,EAAE,KAAK,GAA4B;AACnF,SAAO,2BAA2B,IAAI;AACxC;AAEA,MAAM,gCAAgC,wBAAwB;AAEvD,SAAS,6BAA6B,EAAE,KAAK,GAA4B;AAC9E,SAAO,wCAAwC,KAAK,UAAU,6BAA6B,CAAC;AAC9F;AAEO,SAAS,iBACd,SACA,EAAE,KAAK,GACa;AACpB,MAAI,SAAS;AACX,eAAW,CAAC,MAAM,MAAM,KAAK,OAAO,QAAQ,OAAO,GAAG;AACpD,UAAI,KAAK,SAAS,IAAI,GAAG;AACvB,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
-  "names": []
-}
+{"mappings":"AAqCA,OAAO,SAAS,kBAAkBA,QAA2C;AAC3E,QAAO,UAAU;AAClB;AAED,OAAO,SAAS,0BAA0BA,QAAmD;AAC3F,QAAO,WAAW;AACnB;AAED,OAAO,SAAS,0BAA0BA,QAAmD;AAC3F,QAAO,WAAW;AACnB;AAED,OAAO,SAAS,0BAA0BA,QAAmD;AAC3F,QAAO,WAAW;AACnB;AAED,OAAO,SAAS,wBAAwBA,QAAiD;AACvF,QAAO,SAAS;AACjB;AAED,OAAO,SAAS,iBAAiBA,QAA0C;AACzE,QACE,0BAA0B,OAAO,IACjC,0BAA0B,OAAO,IACjC,0BAA0B,OAAO,IACjC,wBAAwB,OAAO;AAElC;AAED,OAAO,SAAS,oBAAoBA,QAA6C;AAC/E,SAAQ,iBAAiB,OAAO;AACjC;AAED,OAAO,SAAS,2BAA2BA,QAAoD;AAC7F,QAAO,oBAAoB,OAAO,KAAK,kBAAkB,OAAO;AACjE;AAED,OAAO,SAAS,iBAAiBA,QAA0C;AACzE,SAAQ,kBAAkB,OAAO,MAAM,OAAO;AAC/C;AAED,OAAO,SAAS,gBAAgBC,QAA2C;AACzE,KAAI,0BAA0B,OAAO,EAAE;AACrC,SAAO,OAAO;CACf;AAED,KAAI,0BAA0B,OAAO,EAAE;AACrC,SAAO,OAAO;CACf;AAED,KAAI,0BAA0B,OAAO,EAAE;AACrC,SAAO,OAAO;CACf;AAED,QAAO,CAAC,OAAO,GAAI;AACpB;AAED,OAAO,SAAS,cAAcD,QAAuC;AACnE,QAAO,2BAA2B,OAAO,IAAI,OAAO,SAAS;AAC9D;AAED,OAAO,SAAS,gBAAgBA,QAAyC;AACvE,QAAO,2BAA2B,OAAO,IAAI,OAAO,SAAS;AAC9D;AAED,OAAO,SAAS,gBAAgBA,QAAyC;AACvE,QAAO,2BAA2B,OAAO,IAAI,OAAO,SAAS;AAC9D;AAED,OAAO,SAAS,eAAeA,QAAwC;AACrE,QAAO,2BAA2B,OAAO,IAAI,OAAO,SAAS;AAC9D;AAED,OAAO,SAAS,eAAeA,QAAwC;AACrE,QAAO,2BAA2B,OAAO,IAAI,OAAO,SAAS;AAC9D;AAED,OAAO,SAAS,eAAeA,QAAwC;AACrE,QAAO,2BAA2B,OAAO,IAAI,OAAO,SAAS;AAC9D;AAED,OAAO,SAAS,aAAaA,QAAsC;AACjE,QAAO,eAAe,OAAO,MAAM,OAAO;AAC3C;AAED,OAAO,SAAS,cAAcA,QAA6C;AACzE,QAAO,eAAe,OAAO,KAAK,OAAO;AAC1C;AAED,OAAO,SAAS,YAAYA,QAAqC;AAC/D,QAAO,cAAc,OAAO,MAAM,OAAO;AAC1C;AAED,OAAO,SAAS,2BAA2BE,MAAsB;AAC/D,QAAO,KAAK,UAAU,KAAK,YAAY,KAAK,SAAS,IAAI,GAAG,MAAM,IAAI,GAAG,GAAG,KAAK,OAAO;AACzF;AAED,OAAO,SAAS,kCAAkC,EAAE,MAAuB,EAAU;AACnF,QAAO,2BAA2B,KAAK;AACxC;AAED,MAAM,gCAAgC,wBAAwB;AAE9D,OAAO,SAAS,2CAA2C,EAAE,MAAuB,EAAU;AAC5F,QAAO,KAAK,UAAU,8BAA8B;AACrD;AAED,OAAO,SAAS,wCAAwCA,MAAsB;AAC5E,QAAO,KAAK,QAAQ,UAAU,IAAI;AACnC;AAED,OAAO,SAAS,6BAA6BC,QAAiC;AAC5E,QAAO,wCAAwC,2CAA2C,OAAO,CAAC;AACnG;AAED,OAAO,SAAS,iBACdC,SACA,EAAE,MAAuB,EACL;AACpB,KAAI,SAAS;AACX,OAAK,MAAM,CAAC,MAAM,OAAO,IAAI,OAAO,QAAQ,QAAQ,EAAE;AACpD,OAAI,KAAK,SAAS,KAAK,EAAE;AACvB,WAAO;GACR;EACF;CACF;AAED,QAAO;AACR","names":["schema: Schema","schema: ComposedSchema","name: string","schema: ReferenceSchema","schemas: OpenAPIV3.ComponentsObject['schemas']"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/generator-core/src/Schema.ts"],"sourcesContent":["import type { OpenAPIV3 } from 'openapi-types';\n\nexport type Nullified<T, K extends keyof T> = T & Record<K, undefined>;\n\nexport type ReferenceSchema = OpenAPIV3.ReferenceObject;\nexport type ArraySchema = OpenAPIV3.ArraySchemaObject;\nexport type NonArraySchema = OpenAPIV3.NonArraySchemaObject;\nexport type RegularSchema = ArraySchema | NonArraySchema;\n\nexport type NullableSchema = Readonly<Required<Pick<RegularSchema, 'nullable'>>> & RegularSchema;\n\nexport type AnyOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'anyOf'>>> & RegularSchema;\nexport type AllOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'allOf'>>> & RegularSchema;\nexport type OneOfRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'oneOf'>>> & RegularSchema;\nexport type NotRuleComposedSchema = Readonly<Required<Pick<RegularSchema, 'not'>>> & RegularSchema;\nexport type ComposedSchema =\n  | AllOfRuleComposedSchema\n  | AnyOfRuleComposedSchema\n  | NotRuleComposedSchema\n  | OneOfRuleComposedSchema;\n\nexport type NonComposedRegularSchema = Readonly<Nullified<RegularSchema, 'allOf' | 'anyOf' | 'oneOf'>> & RegularSchema;\nexport type NonComposedSchema = NonComposedRegularSchema | ReferenceSchema;\n\nexport type BooleanSchema = NonComposedRegularSchema & Readonly<{ type: 'boolean' }>;\nexport type IntegerSchema = NonComposedRegularSchema & Readonly<{ type: 'integer' }>;\nexport type NumberSchema = NonComposedRegularSchema & Readonly<{ type: 'number' }>;\nexport type ObjectSchema = NonComposedRegularSchema & Readonly<{ type: 'object' }>;\nexport type StringSchema = NonComposedRegularSchema & Readonly<{ type: 'string' }>;\n\nexport type EnumSchema = Readonly<Required<Pick<StringSchema, 'enum'>>> & StringSchema;\nexport type EmptyObjectSchema = ObjectSchema & Readonly<Nullified<ObjectSchema, 'properties'>>;\nexport type NonEmptyObjectSchema = ObjectSchema & Readonly<Required<Pick<ObjectSchema, 'properties'>>>;\nexport type MapSchema = EmptyObjectSchema & Readonly<Required<Pick<ObjectSchema, 'additionalProperties'>>>;\n\nexport type Schema = ReferenceSchema | RegularSchema;\n\nexport function isReferenceSchema(schema: Schema): schema is ReferenceSchema {\n  return '$ref' in schema;\n}\n\nexport function isAnyOfRuleComposedSchema(schema: Schema): schema is AnyOfRuleComposedSchema {\n  return 'anyOf' in schema;\n}\n\nexport function isAllOfRuleComposedSchema(schema: Schema): schema is AllOfRuleComposedSchema {\n  return 'allOf' in schema;\n}\n\nexport function isOneOfRuleComposedSchema(schema: Schema): schema is OneOfRuleComposedSchema {\n  return 'oneOf' in schema;\n}\n\nexport function isNotRuleComposedSchema(schema: Schema): schema is NotRuleComposedSchema {\n  return 'not' in schema;\n}\n\nexport function isComposedSchema(schema: Schema): schema is ComposedSchema {\n  return (\n    isAnyOfRuleComposedSchema(schema) ||\n    isAllOfRuleComposedSchema(schema) ||\n    isOneOfRuleComposedSchema(schema) ||\n    isNotRuleComposedSchema(schema)\n  );\n}\n\nexport function isNonComposedSchema(schema: Schema): schema is NonComposedSchema {\n  return !isComposedSchema(schema);\n}\n\nexport function isNonComposedRegularSchema(schema: Schema): schema is NonComposedRegularSchema {\n  return isNonComposedSchema(schema) && !isReferenceSchema(schema);\n}\n\nexport function isNullableSchema(schema: Schema): schema is NullableSchema {\n  return !isReferenceSchema(schema) && !!schema.nullable;\n}\n\nexport function decomposeSchema(schema: ComposedSchema): readonly Schema[] {\n  if (isAnyOfRuleComposedSchema(schema)) {\n    return schema.anyOf;\n  }\n\n  if (isAllOfRuleComposedSchema(schema)) {\n    return schema.allOf;\n  }\n\n  if (isOneOfRuleComposedSchema(schema)) {\n    return schema.oneOf;\n  }\n\n  return [schema.not];\n}\n\nexport function isArraySchema(schema: Schema): schema is ArraySchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'array';\n}\n\nexport function isBooleanSchema(schema: Schema): schema is BooleanSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'boolean';\n}\n\nexport function isIntegerSchema(schema: Schema): schema is IntegerSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'integer';\n}\n\nexport function isNumberSchema(schema: Schema): schema is NumberSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'number';\n}\n\nexport function isObjectSchema(schema: Schema): schema is ObjectSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'object';\n}\n\nexport function isStringSchema(schema: Schema): schema is StringSchema {\n  return isNonComposedRegularSchema(schema) && schema.type === 'string';\n}\n\nexport function isEnumSchema(schema: Schema): schema is EnumSchema {\n  return isStringSchema(schema) && !!schema.enum;\n}\n\nexport function isEmptyObject(schema: Schema): schema is EmptyObjectSchema {\n  return isObjectSchema(schema) && !schema.properties;\n}\n\nexport function isMapSchema(schema: Schema): schema is MapSchema {\n  return isEmptyObject(schema) && !!schema.additionalProperties;\n}\n\nexport function simplifyFullyQualifiedName(name: string): string {\n  return name.substring(name.lastIndexOf(name.includes('$') ? '$' : '.') + 1, name.length);\n}\n\nexport function convertReferenceSchemaToSpecifier({ $ref }: ReferenceSchema): string {\n  return simplifyFullyQualifiedName($ref);\n}\n\nconst COMPONENTS_SCHEMAS_REF_LENGTH = '#/components/schemas/'.length;\n\nexport function convertReferenceSchemaToFullyQualifiedName({ $ref }: ReferenceSchema): string {\n  return $ref.substring(COMPONENTS_SCHEMAS_REF_LENGTH);\n}\n\nexport function convertFullyQualifiedNameToRelativePath(name: string): string {\n  return name.replace(/[$.]/gu, '/');\n}\n\nexport function convertReferenceSchemaToPath(schema: ReferenceSchema): string {\n  return convertFullyQualifiedNameToRelativePath(convertReferenceSchemaToFullyQualifiedName(schema));\n}\n\nexport function resolveReference(\n  schemas: OpenAPIV3.ComponentsObject['schemas'],\n  { $ref }: ReferenceSchema,\n): Schema | undefined {\n  if (schemas) {\n    for (const [name, schema] of Object.entries(schemas)) {\n      if ($ref.includes(name)) {\n        return schema;\n      }\n    }\n  }\n\n  return undefined;\n}\n"],"version":3}

package/SharedStorage.d.ts

@@ -1,14 +1,13 @@
-import type { $Refs } from '@apidevtools/swagger-parser';
-import type { OpenAPIV3 } from 'openapi-types';
-import type { ReadonlyDeep } from 'type-fest';
-import type { SourceFile } from 'typescript';
-
-type SharedStorage = Readonly<{
-  api: ReadonlyDeep<OpenAPIV3.Document>;
-  apiRefs: $Refs;
-  sources: SourceFile[];
-  pluginStorage: Map<string, unknown>;
-  outputDir?: string;
+import type { $Refs } from "@apidevtools/swagger-parser";
+import type { OpenAPIV3 } from "openapi-types";
+import type { SourceFile, TypeNode } from "typescript";
+export type TransferTypeMaker = (typeArguments: readonly TypeNode[] | undefined) => TypeNode;
+export type TransferTypes = Map<string, TransferTypeMaker>;
+export type SharedStorage = Readonly<{
+	api: OpenAPIV3.Document
+	apiRefs: $Refs
+	outputDir?: string
+	pluginStorage: Map<string, unknown>
+	sources: SourceFile[]
+	transferTypes: TransferTypes
 }>;
-
-export default SharedStorage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin/hilla-generator-core",
-  "version": "24.7.0-alpha9",
+  "version": "24.8.0-alpha1",
   "description": "A Hilla tool to generate TypeScript code from the OpenAPI document",
   "main": "index.js",
   "type": "module",
@@ -9,14 +9,12 @@
   },
   "scripts": {
     "clean:build": "git clean -fx . -e .vite -e node_modules",
-    "build": "concurrently npm:build:*",
-    "build:esbuild": "tsx ../../../scripts/build.ts",
-    "build:dts": "tsc --isolatedModules -p tsconfig.build.json",
-    "build:copy": "cd src && copyfiles **/*.d.ts ..",
+    "build": "tsx ../../../scripts/fast-build.ts",
     "lint": "eslint src test",
     "lint:fix": "eslint src test --fix",
-    "test": "mocha test/**/*.spec.ts --config ../../../.mocharc.cjs",
-    "test:coverage": "c8 --experimental-monocart -c ../../../.c8rc.json npm test",
+    "test": "vitest --run",
+    "test:coverage": "vitest --run --coverage",
+    "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   },
   "exports": {
@@ -43,9 +41,6 @@
     },
     "./SharedStorage.js": {
       "types": "./SharedStorage.d.ts"
-    },
-    "./utils.js": {
-      "default": "./utils.js"
     }
   },
   "repository": {
@@ -71,26 +66,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@apidevtools/swagger-parser": "^10.1.1",
-    "@vaadin/hilla-generator-utils": "24.7.0-alpha9",
-    "meow": "^13.2.0",
-    "openapi-types": "^12.1.3",
+    "@apidevtools/swagger-parser": "10.1.1",
+    "@vaadin/hilla-generator-utils": "24.8.0-alpha1",
+    "meow": "13.2.0",
+    "openapi-types": "12.1.3",
     "typescript": "5.7.3"
-  },
-  "devDependencies": {
-    "@types/chai": "^4.3.20",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^20.17.12",
-    "@types/sinon": "^10.0.20",
-    "@types/sinon-chai": "^3.2.12",
-    "c8": "^10.1.3",
-    "chai": "^4.5.0",
-    "concurrently": "^9.1.2",
-    "copyfiles": "^2.4.1",
-    "mocha": "^11.1.0",
-    "monocart-coverage-reports": "^2.11.5",
-    "sinon": "^16.1.3",
-    "sinon-chai": "^3.7.0",
-    "type-fest": "^4.32.0"
   }
 }

package/File.d.ts

@@ -1,11 +0,0 @@
-import { Blob, type BlobOptions } from 'node:buffer';
-import type { BinaryLike } from 'node:crypto';
-export type FileOptions = Readonly<BlobOptions & {
-    lastModified?: number;
-}>;
-export default class File extends Blob {
-    #private;
-    constructor(fileBits: Array<BinaryLike | Blob>, fileName: string, options?: FileOptions);
-    get name(): string;
-}
-//# sourceMappingURL=File.d.ts.map

package/File.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"File.d.ts","sourceRoot":"","sources":["src/File.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,MAAM,WAAW,GAAG,QAAQ,CAChC,WAAW,GAAG;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CACF,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,IAAI;;gBAGxB,QAAQ,EAAE,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW;IAKvF,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/File.js

@@ -1,15 +0,0 @@
-import { Blob } from "node:buffer";
-class File extends Blob {
-  #name;
-  constructor(fileBits, fileName, options) {
-    super(fileBits, options);
-    this.#name = fileName;
-  }
-  get name() {
-    return this.#name;
-  }
-}
-export {
-  File as default
-};
-//# sourceMappingURL=File.js.map

package/File.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["src/File.ts"],
-  "sourcesContent": ["import { Blob, type BlobOptions } from 'node:buffer';\nimport type { BinaryLike } from 'node:crypto';\n\nexport type FileOptions = Readonly<\n  BlobOptions & {\n    lastModified?: number;\n  }\n>;\n\nexport default class File extends Blob {\n  readonly #name: string;\n\n  constructor(fileBits: Array<BinaryLike | Blob>, fileName: string, options?: FileOptions) {\n    super(fileBits, options);\n    this.#name = fileName;\n  }\n\n  get name(): string {\n    return this.#name;\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,YAA8B;AASvC,MAAO,aAA2B,KAAK;AAAA,EAC5B;AAAA,EAET,YAAY,UAAoC,UAAkB,SAAuB;AACvF,UAAM,UAAU,OAAO;AACvB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK;AAAA,EACd;AACF;",
-  "names": []
-}

package/Generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Generator.d.ts","sourceRoot":"","sources":["src/Generator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,aAAa,MAAM,gDAAgD,CAAC;AAIhF,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAKrD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,MAAM,EAAE,aAAa,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC,CAAC;AAEH,MAAM,CAAC,OAAO,OAAO,SAAS;;gBAMhB,OAAO,EAAE,SAAS,iBAAiB,EAAE,EAAE,OAAO,EAAE,gBAAgB;IAOtE,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;CAoBvD"}

package/Plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["src/Plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,gDAAgD,CAAC;AAChF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gDAAgD,CAAC;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAC;AAEpD,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,MAAM;IAClC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,QAAQ,EAAE,iBAAiB,EAAE,MAAM,EAAE,aAAa;IAK9D,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,QAAQ,KAAK,IAAI,IAAI,MAAM,CAAC;IAE5B,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CACxD;AAED,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC"}

package/PluginManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["src/PluginManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,gDAAgD,CAAC;AAEhF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,aAAa;;gBAGpB,OAAO,EAAE,SAAS,iBAAiB,EAAE,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,EAAE,aAAa;IAiB/F,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CASrD"}

package/ReferenceResolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReferenceResolver.d.ts","sourceRoot":"","sources":["src/ReferenceResolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,CAAC,OAAO,OAAO,iBAAiB;;gBAGxB,MAAM,EAAE,aAAa;IAKjC,OAAO,CAAC,CAAC,SAAS,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,YAAY,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC;CAG7F"}

package/Schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["src/Schema.ts"],"names":[],"mappings":"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"}

package/utils.d.ts

@@ -1,6 +0,0 @@
-export type Nullified<T, K extends keyof T> = T & {
-    [P in K]: undefined;
-};
-export declare function simplifyFullyQualifiedName(name: string): string;
-export declare function convertFullyQualifiedNameToRelativePath(name: string): string;
-//# sourceMappingURL=utils.d.ts.map

package/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,GAAG,SAAS;CAAE,CAAC;AAE1E,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/D;AAID,wBAAgB,uCAAuC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5E"}

package/utils.js

@@ -1,12 +0,0 @@
-function simplifyFullyQualifiedName(name) {
-  return name.substring(name.lastIndexOf(name.includes("$") ? "$" : ".") + 1, name.length);
-}
-const QUALIFIED_NAME_DELIMITER = /[$.]/gu;
-function convertFullyQualifiedNameToRelativePath(name) {
-  return name.replace(QUALIFIED_NAME_DELIMITER, "/");
-}
-export {
-  convertFullyQualifiedNameToRelativePath,
-  simplifyFullyQualifiedName
-};
-//# sourceMappingURL=utils.js.map

package/utils.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["src/utils.ts"],
-  "sourcesContent": ["export type Nullified<T, K extends keyof T> = T & { [P in K]: undefined };\n\nexport function simplifyFullyQualifiedName(name: string): string {\n  return name.substring(name.lastIndexOf(name.includes('$') ? '$' : '.') + 1, name.length);\n}\n\nconst QUALIFIED_NAME_DELIMITER = /[$.]/gu;\n\nexport function convertFullyQualifiedNameToRelativePath(name: string): string {\n  return name.replace(QUALIFIED_NAME_DELIMITER, '/');\n}\n"],
-  "mappings": "AAEO,SAAS,2BAA2B,MAAsB;AAC/D,SAAO,KAAK,UAAU,KAAK,YAAY,KAAK,SAAS,GAAG,IAAI,MAAM,GAAG,IAAI,GAAG,KAAK,MAAM;AACzF;AAEA,MAAM,2BAA2B;AAE1B,SAAS,wCAAwC,MAAsB;AAC5E,SAAO,KAAK,QAAQ,0BAA0B,GAAG;AACnD;",
-  "names": []
-}