@vaadin/hilla-generator-core 24.4.0-alpha1

package/.lintstagedrc.js

@@ -0,0 +1,6 @@
+import { commands, extensions } from '../../../.lintstagedrc.js';
+
+export default {
+  [`src/**/*.{${extensions}}`]: commands,
+  [`test/**/*.{${extensions}}`]: commands,
+};

package/File.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,7 @@
+{
+  "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

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

package/Generator.d.ts.map

@@ -0,0 +1 @@
+{"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/Generator.js

@@ -0,0 +1,37 @@
+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 {
+  Generator as default
+};
+//# sourceMappingURL=Generator.js.map

package/Generator.js.map

@@ -0,0 +1,7 @@
+{
+  "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": []
+}

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/Plugin.d.ts

@@ -0,0 +1,15 @@
+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>;
+}
+export type PluginConstructor = Constructor<Plugin, ConstructorParameters<typeof Plugin>>;
+//# sourceMappingURL=Plugin.d.ts.map

package/Plugin.d.ts.map

@@ -0,0 +1 @@
+{"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/Plugin.js

@@ -0,0 +1,15 @@
+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

package/Plugin.js.map

@@ -0,0 +1,7 @@
+{
+  "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": []
+}

package/PluginManager.d.ts

@@ -0,0 +1,10 @@
+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>;
+}
+//# sourceMappingURL=PluginManager.d.ts.map

package/PluginManager.d.ts.map

@@ -0,0 +1 @@
+{"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;IAgB/F,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CASrD"}

package/PluginManager.js

@@ -0,0 +1,29 @@
+class PluginManager {
+  #plugins;
+  constructor(plugins, resolver, logger) {
+    const standardPlugins = [
+      "BackbonePlugin",
+      "ClientPlugin",
+      "BarrelPlugin",
+      "ModelPlugin",
+      "PushPlugin",
+      "SubTypesPlugin"
+    ];
+    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

package/PluginManager.js.map

@@ -0,0 +1,7 @@
+{
+  "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    ];\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,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": []
+}

package/README.md

@@ -0,0 +1 @@
+# Hilla TypeScript Generator

package/ReferenceResolver.d.ts

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

package/ReferenceResolver.d.ts.map

@@ -0,0 +1 @@
+{"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/ReferenceResolver.js

@@ -0,0 +1,14 @@
+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 {
+  ReferenceResolver as default
+};
+//# sourceMappingURL=ReferenceResolver.js.map

package/ReferenceResolver.js.map

@@ -0,0 +1,7 @@
+{
+  "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": []
+}

package/Schema.d.ts

@@ -0,0 +1,58 @@
+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>;
+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 ComposedSchema = AllOfRuleComposedSchema | AnyOfRuleComposedSchema | NotRuleComposedSchema | OneOfRuleComposedSchema;
+export type NonComposedRegularSchema = Readonly<Nullified<RegularSchema, 'allOf' | 'anyOf' | 'oneOf'>> & RegularSchema;
+export type NonComposedSchema = NonComposedRegularSchema | ReferenceSchema;
+export type BooleanSchema = NonComposedRegularSchema & Readonly<{
+    type: 'boolean';
+}>;
+export type IntegerSchema = NonComposedRegularSchema & Readonly<{
+    type: 'integer';
+}>;
+export type NumberSchema = NonComposedRegularSchema & Readonly<{
+    type: 'number';
+}>;
+export type ObjectSchema = NonComposedRegularSchema & Readonly<{
+    type: 'object';
+}>;
+export type StringSchema = NonComposedRegularSchema & Readonly<{
+    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 Schema = ReferenceSchema | RegularSchema;
+export declare function isReferenceSchema(schema: Schema): schema is ReferenceSchema;
+export declare function isAnyOfRuleComposedSchema(schema: Schema): schema is AnyOfRuleComposedSchema;
+export declare function isAllOfRuleComposedSchema(schema: Schema): schema is AllOfRuleComposedSchema;
+export declare function isOneOfRuleComposedSchema(schema: Schema): schema is OneOfRuleComposedSchema;
+export declare function isNotRuleComposedSchema(schema: Schema): schema is NotRuleComposedSchema;
+export declare function isComposedSchema(schema: Schema): schema is ComposedSchema;
+export declare function isNonComposedSchema(schema: Schema): schema is NonComposedSchema;
+export declare function isNonComposedRegularSchema(schema: Schema): schema is NonComposedRegularSchema;
+export declare function isNullableSchema(schema: Schema): schema is NullableSchema;
+export declare function decomposeSchema(schema: ComposedSchema): readonly Schema[];
+export declare function isArraySchema(schema: Schema): schema is ArraySchema;
+export declare function isBooleanSchema(schema: Schema): schema is BooleanSchema;
+export declare function isIntegerSchema(schema: Schema): schema is IntegerSchema;
+export declare function isNumberSchema(schema: Schema): schema is NumberSchema;
+export declare function isObjectSchema(schema: Schema): schema is ObjectSchema;
+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 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

package/Schema.d.ts.map

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

package/Schema.js

@@ -0,0 +1,109 @@
+import { convertFullyQualifiedNameToRelativePath, simplifyFullyQualifiedName } from "./utils.js";
+function isReferenceSchema(schema) {
+  return "$ref" in schema;
+}
+function isAnyOfRuleComposedSchema(schema) {
+  return "anyOf" in schema;
+}
+function isAllOfRuleComposedSchema(schema) {
+  return "allOf" in schema;
+}
+function isOneOfRuleComposedSchema(schema) {
+  return "oneOf" in schema;
+}
+function isNotRuleComposedSchema(schema) {
+  return "not" in schema;
+}
+function isComposedSchema(schema) {
+  return isAnyOfRuleComposedSchema(schema) || isAllOfRuleComposedSchema(schema) || isOneOfRuleComposedSchema(schema) || isNotRuleComposedSchema(schema);
+}
+function isNonComposedSchema(schema) {
+  return !isComposedSchema(schema);
+}
+function isNonComposedRegularSchema(schema) {
+  return isNonComposedSchema(schema) && !isReferenceSchema(schema);
+}
+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];
+}
+function isArraySchema(schema) {
+  return isNonComposedRegularSchema(schema) && schema.type === "array";
+}
+function isBooleanSchema(schema) {
+  return isNonComposedRegularSchema(schema) && schema.type === "boolean";
+}
+function isIntegerSchema(schema) {
+  return isNonComposedRegularSchema(schema) && schema.type === "integer";
+}
+function isNumberSchema(schema) {
+  return isNonComposedRegularSchema(schema) && schema.type === "number";
+}
+function isObjectSchema(schema) {
+  return isNonComposedRegularSchema(schema) && schema.type === "object";
+}
+function isStringSchema(schema) {
+  return isNonComposedRegularSchema(schema) && schema.type === "string";
+}
+function isEnumSchema(schema) {
+  return isStringSchema(schema) && !!schema.enum;
+}
+function isEmptyObject(schema) {
+  return isObjectSchema(schema) && !schema.properties;
+}
+function isMapSchema(schema) {
+  return isEmptyObject(schema) && !!schema.additionalProperties;
+}
+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

package/Schema.js.map

@@ -0,0 +1,7 @@
+{
+  "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": []
+}

package/SharedStorage.d.js

@@ -0,0 +1 @@
+//# sourceMappingURL=SharedStorage.d.js.map

package/SharedStorage.d.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/SharedStorage.d.ts

@@ -0,0 +1,14 @@
+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;
+}>;
+
+export default SharedStorage;

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@vaadin/hilla-generator-core",
+  "version": "24.4.0-alpha1",
+  "description": "A Hilla tool to generate TypeScript code from the OpenAPI document",
+  "main": "index.js",
+  "type": "module",
+  "engines": {
+    "node": ">= 16.13"
+  },
+  "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 ..",
+    "lint": "eslint src test",
+    "lint:fix": "eslint src test --fix",
+    "test": "mocha test/**/*.spec.ts --config ../../../.mocharc.cjs",
+    "test:coverage": "c8 -c ../../../.c8rc.json npm test",
+    "typecheck": "tsc --noEmit"
+  },
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./File.js": {
+      "default": "./File.js"
+    },
+    "./Generator.js": {
+      "default": "./Generator.js"
+    },
+    "./GeneratorException.js": {
+      "default": "./GeneratorException.js"
+    },
+    "./index.js": {
+      "default": "./index.js"
+    },
+    "./Plugin.js": {
+      "default": "./Plugin.js"
+    },
+    "./Schema.js": {
+      "default": "./Schema.js"
+    },
+    "./SharedStorage.js": {
+      "types": "./SharedStorage.d.ts"
+    },
+    "./utils.js": {
+      "default": "./utils.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vaadin/hilla.git",
+    "directory": "packages/ts/generator-core"
+  },
+  "keywords": [
+    "hilla",
+    "typescript",
+    "generator"
+  ],
+  "author": "Vaadin Ltd.",
+  "license": "Apache 2.0",
+  "bugs": {
+    "url": "https://github.com/vaadin/hilla/issues"
+  },
+  "homepage": "https://hilla.dev",
+  "files": [
+    "*.{d.ts.map,d.ts,js.map,js}"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^10.1.0",
+    "@vaadin/hilla-generator-utils": "24.4.0-alpha1",
+    "meow": "^12.1.1",
+    "openapi-types": "^12.1.3",
+    "typescript": "5.3.2"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.6",
+    "@types/mocha": "^10.0.2",
+    "@types/node": "^20.7.1",
+    "@types/sinon": "^10.0.17",
+    "@types/sinon-chai": "^3.2.10",
+    "c8": "^8.0.1",
+    "chai": "^4.3.10",
+    "concurrently": "^8.2.1",
+    "copyfiles": "^2.4.1",
+    "mocha": "^10.2.0",
+    "rimraf": "^5.0.5",
+    "sinon": "^16.0.0",
+    "sinon-chai": "^3.7.0",
+    "type-fest": "^4.3.2"
+  }
+}

package/utils.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,7 @@
+{
+  "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": []
+}