@nikovirtala/projen-constructs 0.2.1 → 0.2.3

package/node_modules/@mrgrain/jsii-struct-builder/lib/projen/projen-struct.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjenStruct = void 0;
+const path_1 = require("path");
+const spec_1 = require("@jsii/spec");
+const projen_1 = require("projen");
+const ts_interface_1 = require("./ts-interface");
+const builder_1 = require("../builder");
+/**
+ * A component generating a jsii-compatible struct
+ */
+class ProjenStruct extends projen_1.Component {
+    constructor(tsProject, options) {
+        super(tsProject);
+        this.tsProject = tsProject;
+        this.options = options;
+        const fqn = options.fqn ?? `${tsProject.name}.${options.name}`;
+        this.builder = builder_1.Struct.fromSpec({
+            kind: spec_1.TypeKind.Interface,
+            assembly: fqn.split('.').at(0) ?? tsProject.name,
+            fqn,
+            name: options.name,
+            docs: options.docs ?? {
+                summary: options.description ?? options.name,
+            },
+        });
+    }
+    preSynthesize() {
+        const baseDir = this.tsProject.srcdir ?? this.tsProject.outdir;
+        const outputFile = this.options.filePath ?? (0, path_1.join)(baseDir, fqnToPath(this.builder.spec.fqn));
+        new ts_interface_1.TypeScriptInterfaceFile(this.tsProject, outputFile, this.builder.spec, {
+            ...this.options.outputFileOptions,
+            importLocations: {
+                [this.builder.spec.assembly]: relativeImport(outputFile, baseDir),
+                ...this.options.importLocations,
+            },
+        });
+    }
+    get spec() {
+        return this.builder.spec;
+    }
+    add(...props) {
+        this.builder.add(...props);
+        return this;
+    }
+    mixin(...sources) {
+        this.builder.mixin(...sources);
+        return this;
+    }
+    replace(name, replacement) {
+        this.builder.replace(name, replacement);
+        return this;
+    }
+    map(callbackfn) {
+        this.builder.map(callbackfn);
+        return this;
+    }
+    update(name, update) {
+        this.builder.update(name, update);
+        return this;
+    }
+    updateEvery(callbackfn) {
+        this.builder.updateEvery(callbackfn);
+        return this;
+    }
+    updateAll(update) {
+        this.builder.updateAll(update);
+        return this;
+    }
+    rename(from, to) {
+        this.builder.rename(from, to);
+        return this;
+    }
+    allOptional() {
+        this.builder.allOptional();
+        return this;
+    }
+    filter(predicate) {
+        this.builder.filter(predicate);
+        return this;
+    }
+    only(...keep) {
+        this.builder.only(...keep);
+        return this;
+    }
+    omit(...remove) {
+        this.builder.omit(...remove);
+        return this;
+    }
+    withoutDeprecated() {
+        this.builder.withoutDeprecated();
+        return this;
+    }
+    get properties() {
+        return this.builder.properties;
+    }
+    get fqn() {
+        return this.builder.fqn;
+    }
+}
+exports.ProjenStruct = ProjenStruct;
+function relativeImport(from, target) {
+    const diff = path_1.posix.relative((0, path_1.dirname)(from), target);
+    if (!diff) {
+        return '.' + path_1.posix.sep;
+    }
+    return diff + path_1.posix.sep;
+}
+function fqnToPath(fqn) {
+    return (0, path_1.join)(...fqn.split('.').slice(1)) + '.ts';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"projen-struct.js","sourceRoot":"","sources":["../../src/projen/projen-struct.ts"],"names":[],"mappings":"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","sourcesContent":["import { dirname, join, posix } from 'path';\nimport type { Docs, Property } from '@jsii/spec';\nimport { TypeKind } from '@jsii/spec';\nimport type { typescript } from 'projen';\nimport { Component } from 'projen';\nimport type { TypeScriptInterfaceFileOptions } from './ts-interface';\nimport { TypeScriptInterfaceFile } from './ts-interface';\nimport type {\n  HasProperties,\n  IStructBuilder,\n  HasFullyQualifiedName,\n  HasStructSpec,\n} from '../builder';\nimport {\n  Struct,\n} from '../builder';\n\nexport interface ProjenStructOptions {\n  /**\n   * The name of the new struct\n   */\n  readonly name: string;\n  /**\n   * Doc string for the struct\n   *\n   * Just does the summary\n   * If you want to add a full description, use `docs` instead.\n   * This will not be used if `docs` is provided.\n   *\n   * @default - struct name\n   */\n  readonly description?: string;\n  /**\n   * Docs for the struct\n   *\n   * Use this to add a full description.\n   * If you only want to add a summary, use `description` instead.\n   *\n   * @default - none, use `description` if provided\n   */\n  readonly docs?: Docs;\n  /**\n   * The fqn of the struct\n   *\n   * Used to auto-add imports.\n   * All referenced types are loaded based on the fqn hierarchy.\n   *\n   * See `importLocations` for customization options.\n   *\n   * @default `${project.name}.${options.name}`\n   */\n  readonly fqn?: string;\n  /**\n   * Output file path\n   * @default - inside `srcdir` or `outdir` with the fqn turned into a path\n   */\n  readonly filePath?: string;\n  /**\n   * The module locations assemblies should be imported from\n   *\n   * All types are imported from the top-level of the module.\n   * This map can be used to overwrite the default import locations.\n   *\n   * For local imports, the import traverse up a number of levels equivalent to the number of fqn parts of the rendered type.\n   * E.g. if the the rendered type is `pkg.interface`, it is assumed to be at the top-level and imports from the same assembly would be from `./`.\n   * If the rendered type is `pkg.nested.sub.interface` a local import will be from `../../`.\n   *\n   * @default - uses the assembly name for external packages\n   * local imports traverse up a number of levels equivalent to the number of fqn parts\n   */\n  readonly importLocations?: Record<string, string>;\n  /**\n   * Options for the created output `TypeScriptInterfaceFile`\n   */\n  readonly outputFileOptions?: Omit<TypeScriptInterfaceFileOptions, 'importLocations'>;\n}\n\n/**\n * A component generating a jsii-compatible struct\n */\nexport class ProjenStruct extends Component implements IStructBuilder, HasProperties, HasFullyQualifiedName, HasStructSpec {\n  private builder: Struct;\n\n  public constructor(\n    private tsProject: typescript.TypeScriptProject,\n    private options: ProjenStructOptions,\n  ) {\n    super(tsProject);\n\n    const fqn = options.fqn ?? `${tsProject.name}.${options.name}`;\n    this.builder = Struct.fromSpec({\n      kind: TypeKind.Interface,\n      assembly: fqn.split('.').at(0) ?? tsProject.name,\n      fqn,\n      name: options.name,\n      docs: options.docs ?? {\n        summary: options.description ?? options.name,\n      },\n    });\n  }\n\n  preSynthesize(): void {\n    const baseDir = this.tsProject.srcdir ?? this.tsProject.outdir;\n    const outputFile =\n      this.options.filePath ?? join(baseDir, fqnToPath(this.builder.spec.fqn));\n    new TypeScriptInterfaceFile(this.tsProject, outputFile, this.builder.spec, {\n      ...this.options.outputFileOptions,\n      importLocations: {\n        [this.builder.spec.assembly]: relativeImport(outputFile, baseDir),\n        ...this.options.importLocations,\n      },\n    });\n  }\n\n  public get spec() {\n    return this.builder.spec;\n  }\n  add(...props: Property[]): this {\n    this.builder.add(...props);\n    return this;\n  }\n  mixin(...sources: HasProperties[]): this {\n    this.builder.mixin(...sources);\n    return this;\n  }\n  replace(name: string, replacement: Property): IStructBuilder {\n    this.builder.replace(name, replacement);\n    return this;\n  }\n  map(callbackfn: (prop: Property) => Property): this {\n    this.builder.map(callbackfn);\n    return this;\n  }\n  update(name: string, update: Partial<Property>): this {\n    this.builder.update(name, update);\n    return this;\n  }\n  updateEvery(callbackfn: (prop: Property) => Partial<Property>): this {\n    this.builder.updateEvery(callbackfn);\n    return this;\n  }\n  updateAll(update: Partial<Property>): this {\n    this.builder.updateAll(update);\n    return this;\n  }\n  rename(from: string, to: string): this {\n    this.builder.rename(from, to);\n    return this;\n  }\n  allOptional(): this {\n    this.builder.allOptional();\n    return this;\n  }\n  filter(predicate: (prop: Property) => boolean): this {\n    this.builder.filter(predicate);\n    return this;\n  }\n  only(...keep: string[]): this {\n    this.builder.only(...keep);\n    return this;\n  }\n  omit(...remove: string[]): this {\n    this.builder.omit(...remove);\n    return this;\n  }\n  withoutDeprecated(): this {\n    this.builder.withoutDeprecated();\n    return this;\n  }\n  public get properties(): Property[] {\n    return this.builder.properties;\n  }\n  public get fqn(): string {\n    return this.builder.fqn;\n  }\n}\n\nfunction relativeImport(from: string, target: string): string {\n  const diff = posix.relative(dirname(from), target);\n  if (!diff) {\n    return '.' + posix.sep;\n  }\n  return diff + posix.sep;\n}\n\nfunction fqnToPath(fqn: string): string {\n  return join(...fqn.split('.').slice(1)) + '.ts';\n}\n"]}

package/node_modules/@mrgrain/jsii-struct-builder/lib/projen/ts-interface.d.ts

@@ -0,0 +1,15 @@
+import type { InterfaceType } from '@jsii/spec';
+import type { Project, SourceCodeOptions } from 'projen';
+import { TextFile } from 'projen';
+import type { TypeScriptRendererOptions } from '../renderer';
+/**
+ * Options for `TypeScriptInterfaceFile`.
+ */
+export interface TypeScriptInterfaceFileOptions extends TypeScriptRendererOptions, SourceCodeOptions {
+}
+/**
+ * A TypeScript interface rendered from a jsii interface specification
+ */
+export declare class TypeScriptInterfaceFile extends TextFile {
+    constructor(project: Project, filePath: string, spec: InterfaceType, options?: TypeScriptInterfaceFileOptions);
+}

package/node_modules/@mrgrain/jsii-struct-builder/lib/projen/ts-interface.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptInterfaceFile = void 0;
+const projen_1 = require("projen");
+const renderer_1 = require("../renderer");
+/**
+ * A TypeScript interface rendered from a jsii interface specification
+ */
+class TypeScriptInterfaceFile extends projen_1.TextFile {
+    constructor(project, filePath, spec, options = {}) {
+        super(project, filePath, options);
+        const renderer = new renderer_1.TypeScriptRenderer(options);
+        this.addLine(`// ${this.marker}`);
+        this.addLine(renderer.renderStructSpec(spec));
+    }
+}
+exports.TypeScriptInterfaceFile = TypeScriptInterfaceFile;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHMtaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb2plbi90cy1pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsbUNBQWtDO0FBRWxDLDBDQUFpRDtBQU9qRDs7R0FFRztBQUNILE1BQWEsdUJBQXdCLFNBQVEsaUJBQVE7SUFDbkQsWUFDRSxPQUFnQixFQUNoQixRQUFnQixFQUNoQixJQUFtQixFQUNuQixVQUEwQyxFQUFFO1FBRTVDLEtBQUssQ0FBQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBRWxDLE1BQU0sUUFBUSxHQUFHLElBQUksNkJBQWtCLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDakQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO1FBQ2xDLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDaEQsQ0FBQztDQUNGO0FBYkQsMERBYUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEludGVyZmFjZVR5cGUgfSBmcm9tICdAanNpaS9zcGVjJztcbmltcG9ydCB0eXBlIHsgUHJvamVjdCwgU291cmNlQ29kZU9wdGlvbnMgfSBmcm9tICdwcm9qZW4nO1xuaW1wb3J0IHsgVGV4dEZpbGUgfSBmcm9tICdwcm9qZW4nO1xuaW1wb3J0IHR5cGUgeyBUeXBlU2NyaXB0UmVuZGVyZXJPcHRpb25zIH0gZnJvbSAnLi4vcmVuZGVyZXInO1xuaW1wb3J0IHsgVHlwZVNjcmlwdFJlbmRlcmVyIH0gZnJvbSAnLi4vcmVuZGVyZXInO1xuXG4vKipcbiAqIE9wdGlvbnMgZm9yIGBUeXBlU2NyaXB0SW50ZXJmYWNlRmlsZWAuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVHlwZVNjcmlwdEludGVyZmFjZUZpbGVPcHRpb25zIGV4dGVuZHMgVHlwZVNjcmlwdFJlbmRlcmVyT3B0aW9ucywgU291cmNlQ29kZU9wdGlvbnMge31cblxuLyoqXG4gKiBBIFR5cGVTY3JpcHQgaW50ZXJmYWNlIHJlbmRlcmVkIGZyb20gYSBqc2lpIGludGVyZmFjZSBzcGVjaWZpY2F0aW9uXG4gKi9cbmV4cG9ydCBjbGFzcyBUeXBlU2NyaXB0SW50ZXJmYWNlRmlsZSBleHRlbmRzIFRleHRGaWxlIHtcbiAgcHVibGljIGNvbnN0cnVjdG9yKFxuICAgIHByb2plY3Q6IFByb2plY3QsXG4gICAgZmlsZVBhdGg6IHN0cmluZyxcbiAgICBzcGVjOiBJbnRlcmZhY2VUeXBlLFxuICAgIG9wdGlvbnM6IFR5cGVTY3JpcHRJbnRlcmZhY2VGaWxlT3B0aW9ucyA9IHt9LFxuICApIHtcbiAgICBzdXBlcihwcm9qZWN0LCBmaWxlUGF0aCwgb3B0aW9ucyk7XG5cbiAgICBjb25zdCByZW5kZXJlciA9IG5ldyBUeXBlU2NyaXB0UmVuZGVyZXIob3B0aW9ucyk7XG4gICAgdGhpcy5hZGRMaW5lKGAvLyAke3RoaXMubWFya2VyfWApO1xuICAgIHRoaXMuYWRkTGluZShyZW5kZXJlci5yZW5kZXJTdHJ1Y3RTcGVjKHNwZWMpKTtcbiAgfVxufVxuIl19

package/node_modules/@mrgrain/jsii-struct-builder/lib/renderer/index.d.ts

@@ -0,0 +1 @@
+export * from './typescript';

package/node_modules/@mrgrain/jsii-struct-builder/lib/renderer/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./typescript"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVuZGVyZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdHlwZXNjcmlwdCc7XG4iXX0=

package/node_modules/@mrgrain/jsii-struct-builder/lib/renderer/typescript.d.ts

@@ -0,0 +1,53 @@
+import type { InterfaceType, Property } from '@jsii/spec';
+import type { HasStructSpec } from '../builder';
+/**
+ * Options for `TypeScriptRenderer`.
+ */
+export interface TypeScriptRendererOptions {
+    /**
+     * The module locations assemblies should be imported from
+     *
+     * All types are imported from the top-level of the module.
+     * This map can be used to overwrite the default import locations.
+     *
+     * For local imports, the import traverse up a number of levels equivalent to the number of fqn parts of the rendered type.
+     * E.g. if the the rendered type is `pkg.interface`, it is assumed to be at the top-level and imports from the same assembly would be from `./`.
+     * If the rendered type is `pkg.nested.sub.interface` a local import will be from `../../`.
+     *
+     * @default - uses the assembly name for external packages
+     * local imports traverse up a number of levels equivalent to the number of fqn parts
+     */
+    readonly importLocations?: Record<string, string>;
+    /**
+     * Indentation size
+     *
+     * @default 2
+     */
+    readonly indent?: number;
+    /**
+     * Use explicit `type` imports when importing referenced modules.
+     *
+     * @see https://www.typescriptlang.org/docs/handbook/modules.html#importing-types
+     * @default true
+     */
+    readonly useTypeImports?: boolean;
+}
+/**
+ * Jsii to TypeScript renderer
+ */
+export declare class TypeScriptRenderer {
+    private buffer;
+    private options;
+    constructor(options?: TypeScriptRendererOptions);
+    /**
+     * Render something that has a struct spec
+     */
+    renderStruct(struct: HasStructSpec): string;
+    /**
+     * Render a jsii InterfaceType spec
+     */
+    renderStructSpec(spec: InterfaceType): string;
+    protected renderImports(modules: Map<string, Set<string>>): void;
+    protected renderProperty(p: Property, containingFqn: string): void;
+    protected renderDocBlock(lines: string[]): void;
+}

package/node_modules/@mrgrain/jsii-struct-builder/lib/renderer/typescript.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptRenderer = void 0;
+const spec_1 = require("@jsii/spec");
+const private_1 = require("../private");
+/**
+ * Jsii to TypeScript renderer
+ */
+class TypeScriptRenderer {
+    constructor(options = {}) {
+        this.options = {
+            importLocations: options.importLocations ?? {},
+            indent: options.indent ?? 2,
+            useTypeImports: options.useTypeImports ?? true,
+        };
+        this.buffer = new CodeBuffer(' '.repeat(this.options.indent));
+    }
+    /**
+     * Render something that has a struct spec
+     */
+    renderStruct(struct) {
+        return this.renderStructSpec(struct.spec);
+    }
+    /**
+     * Render a jsii InterfaceType spec
+     */
+    renderStructSpec(spec) {
+        this.buffer.flush();
+        this.renderImports(extractImports(spec, this.options.importLocations));
+        this.buffer.line();
+        this.renderDocBlock(docsToLines(spec.docs));
+        this.buffer.open(`export interface ${spec.name} {`);
+        spec.properties?.forEach((p) => this.renderProperty(p, spec.fqn));
+        this.buffer.close('}');
+        this.buffer.line();
+        return this.buffer.flush().join('\n');
+    }
+    renderImports(modules) {
+        Array.from(modules.keys())
+            .sort(private_1.comparePath)
+            .forEach((mod) => {
+            const imports = Array.from(modules.get(mod)?.values() || []);
+            const importStmt = this.options.useTypeImports
+                ? 'import type'
+                : 'import';
+            this.buffer.line(`${importStmt} { ${imports
+                .sort(private_1.compareLowerCase)
+                .join(', ')} } from '${mod}';`);
+        });
+    }
+    renderProperty(p, containingFqn) {
+        const docs = structuredClone(p.docs);
+        if (docs) {
+            this.renderDocBlock(docsToLines(docs));
+        }
+        this.buffer.line(`readonly ${p.name}${p.optional ? '?' : ''}: ${typeRefToType(p.type, containingFqn)};`);
+    }
+    renderDocBlock(lines) {
+        if (!lines.length) {
+            return;
+        }
+        this.buffer.line('/**');
+        lines.forEach((line) => this.buffer.line(` * ${line}`));
+        this.buffer.line(' */');
+    }
+}
+exports.TypeScriptRenderer = TypeScriptRenderer;
+class CodeBuffer {
+    constructor(indent = ' ') {
+        this.indent = indent;
+        this.lines = new Array();
+        this.indentLevel = 0;
+    }
+    flush() {
+        const current = this.lines;
+        this.reset();
+        return current;
+    }
+    line(code) {
+        const prefix = this.indent.repeat(this.indentLevel);
+        this.lines.push((prefix + (code ?? '')).trimEnd());
+    }
+    open(code) {
+        if (code) {
+            this.line(code);
+        }
+        this.indentLevel++;
+    }
+    close(code) {
+        if (this.indentLevel === 0) {
+            throw new Error('Cannot decrease indent level below zero');
+        }
+        this.indentLevel--;
+        if (code) {
+            this.line(code);
+        }
+    }
+    reset() {
+        this.lines = new Array();
+        this.indentLevel = 0;
+    }
+}
+function docsToLines(docs) {
+    if (!docs) {
+        return [];
+    }
+    const lines = new Array();
+    if (docs.summary) {
+        lines.push(docs.summary);
+    }
+    if (docs.remarks) {
+        lines.push(...docs.remarks.split('\n'));
+    }
+    if (docs.default) {
+        lines.push(`@default ${docs.default}`);
+    }
+    if (docs.deprecated) {
+        lines.push(`@deprecated ${docs.deprecated}`);
+    }
+    if (docs.stability) {
+        lines.push(`@stability ${docs.stability}`);
+    }
+    if (docs.custom) {
+        Object.entries(docs.custom).forEach((entry) => {
+            const [tag, value] = entry;
+            lines.push(`@${tag} ${value}`);
+        });
+    }
+    return lines;
+}
+function typeRefToType(t, containingFqn) {
+    if ((0, spec_1.isPrimitiveTypeReference)(t)) {
+        return t.primitive;
+    }
+    if ((0, spec_1.isNamedTypeReference)(t)) {
+        return t.fqn.split('.').slice(1).join('.');
+    }
+    if ((0, spec_1.isCollectionTypeReference)(t)) {
+        switch (t.collection.kind) {
+            case spec_1.CollectionKind.Array:
+                return `Array<${typeRefToType(t.collection.elementtype, containingFqn)}>`;
+            case spec_1.CollectionKind.Map:
+                return `Record<string, ${typeRefToType(t.collection.elementtype, containingFqn)}>`;
+            default:
+                return 'any';
+        }
+    }
+    if ((0, spec_1.isUnionTypeReference)(t)) {
+        return t.union.types
+            .map((ut) => typeRefToType(ut, containingFqn))
+            .join(' | ');
+    }
+    return 'any';
+}
+function extractImports(spec, importLocations) {
+    const refs = spec.properties?.flatMap((p) => collectFQNs(p.type)) || [];
+    return refs.reduce((mods, ref) => {
+        const packageName = fqnToImportName(ref, spec.fqn, importLocations);
+        const imports = mods.get(packageName) || new Set();
+        const importName = ref.split('.').slice(1)[0] || ref;
+        return mods.set(packageName, imports.add(importName));
+    }, new Map());
+}
+function fqnToImportName(fqn, importingFqn, importLocations) {
+    const localAssembly = importingFqn.split('.', 1)[0];
+    const importAssembly = fqn.split('.', 1)[0];
+    // we have a custom import path
+    if (importLocations[importAssembly]) {
+        return importLocations[importAssembly];
+    }
+    // this is the same assembly, try to guess the path to the root
+    if (importAssembly === localAssembly) {
+        const fqnParts = importingFqn.split('.').length;
+        if (fqnParts <= 2) {
+            return './';
+        }
+        return '../'.repeat(fqnParts - 2);
+    }
+    // regular third party module
+    return importAssembly;
+}
+function collectFQNs(t) {
+    if ((0, spec_1.isNamedTypeReference)(t)) {
+        return [t.fqn];
+    }
+    if ((0, spec_1.isUnionTypeReference)(t)) {
+        return t.union.types.flatMap(collectFQNs);
+    }
+    if ((0, spec_1.isCollectionTypeReference)(t)) {
+        return collectFQNs(t.collection.elementtype);
+    }
+    return [];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript.js","sourceRoot":"","sources":["../../src/renderer/typescript.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  Docs,\n  InterfaceType,\n  Property,\n  TypeReference,\n} from '@jsii/spec';\nimport {\n  CollectionKind,\n  isCollectionTypeReference,\n  isNamedTypeReference,\n  isPrimitiveTypeReference,\n  isUnionTypeReference,\n} from '@jsii/spec';\nimport type { HasStructSpec } from '../builder';\nimport { compareLowerCase, comparePath } from '../private';\n\n/**\n * Options for `TypeScriptRenderer`.\n */\nexport interface TypeScriptRendererOptions {\n  /**\n   * The module locations assemblies should be imported from\n   *\n   * All types are imported from the top-level of the module.\n   * This map can be used to overwrite the default import locations.\n   *\n   * For local imports, the import traverse up a number of levels equivalent to the number of fqn parts of the rendered type.\n   * E.g. if the the rendered type is `pkg.interface`, it is assumed to be at the top-level and imports from the same assembly would be from `./`.\n   * If the rendered type is `pkg.nested.sub.interface` a local import will be from `../../`.\n   *\n   * @default - uses the assembly name for external packages\n   * local imports traverse up a number of levels equivalent to the number of fqn parts\n   */\n  readonly importLocations?: Record<string, string>;\n\n  /**\n   * Indentation size\n   *\n   * @default 2\n   */\n  readonly indent?: number;\n\n  /**\n   * Use explicit `type` imports when importing referenced modules.\n   *\n   * @see https://www.typescriptlang.org/docs/handbook/modules.html#importing-types\n   * @default true\n   */\n  readonly useTypeImports?: boolean;\n}\n\n/**\n * Jsii to TypeScript renderer\n */\nexport class TypeScriptRenderer {\n  private buffer: CodeBuffer;\n  private options: Required<TypeScriptRendererOptions>;\n\n  public constructor(options: TypeScriptRendererOptions = {}) {\n    this.options = {\n      importLocations: options.importLocations ?? {},\n      indent: options.indent ?? 2,\n      useTypeImports: options.useTypeImports ?? true,\n    };\n    this.buffer = new CodeBuffer(' '.repeat(this.options.indent));\n  }\n\n  /**\n   * Render something that has a struct spec\n   */\n  public renderStruct(struct: HasStructSpec): string {\n    return this.renderStructSpec(struct.spec);\n  }\n\n  /**\n   * Render a jsii InterfaceType spec\n   */\n  public renderStructSpec(spec: InterfaceType): string {\n    this.buffer.flush();\n\n    this.renderImports(extractImports(spec, this.options.importLocations));\n    this.buffer.line();\n    this.renderDocBlock(docsToLines(spec.docs));\n    this.buffer.open(`export interface ${spec.name} {`);\n    spec.properties?.forEach((p) => this.renderProperty(p, spec.fqn));\n    this.buffer.close('}');\n    this.buffer.line();\n\n    return this.buffer.flush().join('\\n');\n  }\n\n  protected renderImports(modules: Map<string, Set<string>>) {\n    Array.from(modules.keys())\n      .sort(comparePath)\n      .forEach((mod) => {\n        const imports = Array.from(modules.get(mod)?.values() || []);\n        const importStmt = this.options.useTypeImports\n          ? 'import type'\n          : 'import';\n        this.buffer.line(\n          `${importStmt} { ${imports\n            .sort(compareLowerCase)\n            .join(', ')} } from '${mod}';`,\n        );\n      });\n  }\n\n  protected renderProperty(p: Property, containingFqn: string) {\n    const docs = structuredClone(p.docs);\n    if (docs) {\n      this.renderDocBlock(docsToLines(docs));\n    }\n\n    this.buffer.line(\n      `readonly ${p.name}${p.optional ? '?' : ''}: ${typeRefToType(\n        p.type,\n        containingFqn,\n      )};`,\n    );\n  }\n\n  protected renderDocBlock(lines: string[]) {\n    if (!lines.length) {\n      return;\n    }\n\n    this.buffer.line('/**');\n    lines.forEach((line) => this.buffer.line(` * ${line}`));\n    this.buffer.line(' */');\n  }\n}\n\nclass CodeBuffer {\n  private lines = new Array<string>();\n  private indentLevel = 0;\n\n  public constructor(private readonly indent = ' ') {}\n\n  public flush(): string[] {\n    const current = this.lines;\n    this.reset();\n\n    return current;\n  }\n\n  public line(code?: string) {\n    const prefix = this.indent.repeat(this.indentLevel);\n    this.lines.push((prefix + (code ?? '')).trimEnd());\n  }\n\n  public open(code?: string) {\n    if (code) {\n      this.line(code);\n    }\n\n    this.indentLevel++;\n  }\n\n  public close(code?: string) {\n    if (this.indentLevel === 0) {\n      throw new Error('Cannot decrease indent level below zero');\n    }\n    this.indentLevel--;\n\n    if (code) {\n      this.line(code);\n    }\n  }\n\n  private reset(): void {\n    this.lines = new Array<string>();\n    this.indentLevel = 0;\n  }\n}\n\nfunction docsToLines(docs?: Docs): string[] {\n  if (!docs) {\n    return [];\n  }\n\n  const lines = new Array<string>();\n\n  if (docs.summary) {\n    lines.push(docs.summary);\n  }\n  if (docs.remarks) {\n    lines.push(...docs.remarks.split('\\n'));\n  }\n  if (docs.default) {\n    lines.push(`@default ${docs.default}`);\n  }\n  if (docs.deprecated) {\n    lines.push(`@deprecated ${docs.deprecated}`);\n  }\n  if (docs.stability) {\n    lines.push(`@stability ${docs.stability}`);\n  }\n  if (docs.custom) {\n    Object.entries(docs.custom).forEach((entry) => {\n      const [tag, value] = entry;\n      lines.push(`@${tag} ${value}`);\n    });\n  }\n\n  return lines;\n}\n\nfunction typeRefToType(t: TypeReference, containingFqn: string): string {\n  if (isPrimitiveTypeReference(t)) {\n    return t.primitive;\n  }\n\n  if (isNamedTypeReference(t)) {\n    return t.fqn.split('.').slice(1).join('.');\n  }\n\n  if (isCollectionTypeReference(t)) {\n    switch (t.collection.kind) {\n      case CollectionKind.Array:\n        return `Array<${typeRefToType(\n          t.collection.elementtype,\n          containingFqn,\n        )}>`;\n      case CollectionKind.Map:\n        return `Record<string, ${typeRefToType(\n          t.collection.elementtype,\n          containingFqn,\n        )}>`;\n      default:\n        return 'any';\n    }\n  }\n  if (isUnionTypeReference(t)) {\n    return t.union.types\n      .map((ut) => typeRefToType(ut, containingFqn))\n      .join(' | ');\n  }\n\n  return 'any';\n}\n\nfunction extractImports(\n  spec: InterfaceType,\n  importLocations: Record<string, string>,\n): Map<string, Set<string>> {\n  const refs = spec.properties?.flatMap((p) => collectFQNs(p.type)) || [];\n  return refs.reduce((mods, ref) => {\n    const packageName = fqnToImportName(ref, spec.fqn, importLocations);\n    const imports = mods.get(packageName) || new Set();\n    const importName = ref.split('.').slice(1)[0] || ref;\n    return mods.set(packageName, imports.add(importName));\n  }, new Map<string, Set<string>>());\n}\n\nfunction fqnToImportName(\n  fqn: string,\n  importingFqn: string,\n  importLocations: Record<string, string>,\n): string {\n  const localAssembly = importingFqn.split('.', 1)[0];\n  const importAssembly = fqn.split('.', 1)[0];\n\n  // we have a custom import path\n  if (importLocations[importAssembly]) {\n    return importLocations[importAssembly];\n  }\n\n  // this is the same assembly, try to guess the path to the root\n  if (importAssembly === localAssembly) {\n    const fqnParts = importingFqn.split('.').length;\n    if (fqnParts <= 2) {\n      return './';\n    }\n    return '../'.repeat(fqnParts - 2);\n  }\n\n  // regular third party module\n  return importAssembly;\n}\n\nfunction collectFQNs(t: TypeReference): string[] {\n  if (isNamedTypeReference(t)) {\n    return [t.fqn];\n  }\n\n  if (isUnionTypeReference(t)) {\n    return t.union.types.flatMap(collectFQNs);\n  }\n\n  if (isCollectionTypeReference(t)) {\n    return collectFQNs(t.collection.elementtype);\n  }\n\n  return [];\n}\n"]}

package/node_modules/@mrgrain/jsii-struct-builder/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@mrgrain/jsii-struct-builder",
+  "description": "Build jsii structs with ease",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:mrgrain/jsii-struct-builder.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "logo": "npx projen logo",
+    "package": "npx projen package",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Momo Kornher",
+    "url": "https://moritzkornher.de",
+    "organization": false
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^29.5.14",
+    "@types/node": "ts5.8",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "commit-and-tag-version": "^12",
+    "constructs": "^10.0.0",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^3.10.1",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^16",
+    "mrpj": "^0.2.5",
+    "projen": "^0.98.4",
+    "ts-jest": "^29.4.5",
+    "ts-node": "^10.9.2",
+    "typescript": "5.8.x"
+  },
+  "peerDependencies": {
+    "projen": "x.x.x"
+  },
+  "dependencies": {
+    "@jsii/spec": "^1.117.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/mrgrain/jsii-struct-builder",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.7.64",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}

package/node_modules/ajv/.runkit_example.js

@@ -0,0 +1,23 @@
+const Ajv = require("ajv")
+const ajv = new Ajv({allErrors: true})
+
+const schema = {
+  type: "object",
+  properties: {
+    foo: {type: "string"},
+    bar: {type: "number", maximum: 3},
+  },
+  required: ["foo", "bar"],
+  additionalProperties: false,
+}
+
+const validate = ajv.compile(schema)
+
+test({foo: "abc", bar: 2})
+test({foo: 2, bar: 4})
+
+function test(data) {
+  const valid = validate(data)
+  if (valid) console.log("Valid!")
+  else console.log("Invalid: " + ajv.errorsText(validate.errors))
+}

package/node_modules/ajv/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2021 Evgeny Poberezkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+