@nikovirtala/projen-constructs 0.2.1 → 0.2.2

package/node_modules/@jsii/spec/lib/assembly.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * NOTE: Next time we change anything there, be sure to address https://github.com/aws/jsii/issues/4911
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeKind = exports.CANONICAL_ANY = exports.PrimitiveType = exports.CollectionKind = exports.Stability = exports.SchemaVersion = exports.SPEC_FILE_NAME_COMPRESSED = exports.SPEC_FILE_NAME = void 0;
+exports.isNamedTypeReference = isNamedTypeReference;
+exports.isPrimitiveTypeReference = isPrimitiveTypeReference;
+exports.isCollectionTypeReference = isCollectionTypeReference;
+exports.isUnionTypeReference = isUnionTypeReference;
+exports.isIntersectionTypeReference = isIntersectionTypeReference;
+exports.isMethod = isMethod;
+exports.isProperty = isProperty;
+exports.isClassType = isClassType;
+exports.isInterfaceType = isInterfaceType;
+exports.isEnumType = isEnumType;
+exports.isClassOrInterfaceType = isClassOrInterfaceType;
+exports.describeTypeReference = describeTypeReference;
+exports.isDeprecated = isDeprecated;
+/**
+ * Expected file name for jsii assembly or instructions to compressed assembly.
+ */
+exports.SPEC_FILE_NAME = '.jsii';
+/**
+ * Expected file name for compressed assemblies.
+ */
+exports.SPEC_FILE_NAME_COMPRESSED = `${exports.SPEC_FILE_NAME}.gz`;
+/**
+ * Versions of the JSII Assembly Specification.
+ */
+var SchemaVersion;
+(function (SchemaVersion) {
+    SchemaVersion["LATEST"] = "jsii/0.10.0";
+})(SchemaVersion || (exports.SchemaVersion = SchemaVersion = {}));
+/**
+ * API Stability levels. These are modeled after the `node` stability index.
+ *
+ * @see https://nodejs.org/api/documentation.html#documentation_stability_index.
+ */
+var Stability;
+(function (Stability) {
+    /**
+     * The API may emit warnings. Backward compatibility is not guaranteed.
+     *
+     * More information about the deprecation can usually be found in the
+     * `deprecated` field.
+     */
+    Stability["Deprecated"] = "deprecated";
+    /**
+     * This API is still under active development and subject to non-backward
+     * compatible changes or removal in any future version. Use of the API is
+     * not recommended in production environments. Experimental APIs are not
+     * subject to the Semantic Versioning model.
+     */
+    Stability["Experimental"] = "experimental";
+    /**
+     * This API is subject to the Semantic Versioning model and may not change
+     * in breaking ways in a subsequent minor or patch version.
+     */
+    Stability["Stable"] = "stable";
+    /**
+     * This API is an representation of an API managed elsewhere and follows
+     * the other API's versioning model.
+     */
+    Stability["External"] = "external";
+})(Stability || (exports.Stability = Stability = {}));
+/**
+ * Kinds of collections.
+ */
+var CollectionKind;
+(function (CollectionKind) {
+    /**
+     * An array, or a list of some element type.
+     */
+    CollectionKind["Array"] = "array";
+    /**
+     * A map of a string to some element type.
+     */
+    CollectionKind["Map"] = "map";
+})(CollectionKind || (exports.CollectionKind = CollectionKind = {}));
+/**
+ * Kinds of primitive types.
+ */
+var PrimitiveType;
+(function (PrimitiveType) {
+    /**
+     * A JSON date (represented as it's ISO-8601 string form).
+     */
+    PrimitiveType["Date"] = "date";
+    /**
+     * A plain string.
+     */
+    PrimitiveType["String"] = "string";
+    /**
+     * A number (integer or float).
+     */
+    PrimitiveType["Number"] = "number";
+    /**
+     * A boolean value.
+     */
+    PrimitiveType["Boolean"] = "boolean";
+    /**
+     * A JSON object
+     */
+    PrimitiveType["Json"] = "json";
+    /**
+     * Value with "any" or "unknown" type (aka Object). Values typed `any` may
+     * be `null` or `undefined`.
+     */
+    PrimitiveType["Any"] = "any";
+})(PrimitiveType || (exports.PrimitiveType = PrimitiveType = {}));
+/**
+ * The standard representation of the `any` type (includes optionality marker).
+ */
+exports.CANONICAL_ANY = {
+    primitive: PrimitiveType.Any,
+};
+function isNamedTypeReference(ref) {
+    return !!ref?.fqn;
+}
+function isPrimitiveTypeReference(ref) {
+    return !!ref?.primitive;
+}
+function isCollectionTypeReference(ref) {
+    return !!ref?.collection;
+}
+function isUnionTypeReference(ref) {
+    return !!ref?.union;
+}
+function isIntersectionTypeReference(ref) {
+    return !!ref?.intersection;
+}
+/**
+ * Determines whether a Callable is a Method or not (if not, it's an initializer)
+ *
+ * @param callable the callable to be checked.
+ */
+function isMethod(callable) {
+    return !!callable.name;
+}
+/**
+ * Returns whether an API element looks like a property
+ */
+function isProperty(member) {
+    return !!member.name && !!member.type;
+}
+/**
+ * Kinds of types.
+ */
+var TypeKind;
+(function (TypeKind) {
+    TypeKind["Class"] = "class";
+    TypeKind["Enum"] = "enum";
+    TypeKind["Interface"] = "interface";
+})(TypeKind || (exports.TypeKind = TypeKind = {}));
+function isClassType(type) {
+    return type?.kind === TypeKind.Class;
+}
+function isInterfaceType(type) {
+    return type?.kind === TypeKind.Interface;
+}
+function isEnumType(type) {
+    return type?.kind === TypeKind.Enum;
+}
+/**
+ * Return whether this type is a class or interface type
+ */
+function isClassOrInterfaceType(type) {
+    return isClassType(type) || isInterfaceType(type);
+}
+/**
+ * Return a string representation of the given type reference.
+ */
+function describeTypeReference(type) {
+    if (type === undefined) {
+        return 'void';
+    }
+    if (isNamedTypeReference(type)) {
+        return type.fqn;
+    }
+    if (isPrimitiveTypeReference(type)) {
+        return type.primitive;
+    }
+    if (isCollectionTypeReference(type)) {
+        return `${type.collection.kind}<${describeTypeReference(type.collection.elementtype)}>`;
+    }
+    if (isUnionTypeReference(type)) {
+        const unionType = type.union.types.map(describeTypeReference).join(' | ');
+        return unionType;
+    }
+    throw new Error('Unrecognized type reference');
+}
+/**
+ * Determines whether an entity is deprecated.
+ *
+ * @param entity the entity to be checked.
+ *
+ * @returns true if the entity is marked as deprecated.
+ */
+function isDeprecated(entity) {
+    return entity?.docs?.stability === Stability.Deprecated;
+}
+//# sourceMappingURL=assembly.js.map

package/node_modules/@jsii/spec/lib/configuration.d.ts

@@ -0,0 +1,147 @@
+import { Stability } from './assembly';
+/**
+ * Structure of jsii configuration in package.json
+ */
+export interface Config {
+    /**
+     * Output directory of typescript compiler
+     */
+    outdir?: string;
+    /**
+     * Determines the format of the jsii toolchain version string that will be
+     * included in the .jsii assembly file's jsiiVersion attribute.
+     *
+     * full (the default) - a version number including a commit hash will be used
+     * example: 0.14.3 (build 1b1062d)
+     *
+     * short - only the version number of jsii will be used
+     * example: 0.14.3
+     */
+    versionFormat?: 'full' | 'short';
+    /**
+     * Defines which target languages the module supports.
+     */
+    targets?: {
+        java?: {
+            package: string;
+            /**
+             * groupId and artifactId for generated maven package.
+             */
+            maven: {
+                groupId: string;
+                artifactId: string;
+                /**
+                 * optional version suffix for maven module version
+                 */
+                versionSuffix?: string;
+            };
+        };
+        python?: {
+            /**
+             * name of generated Python module, which will be used by users in import
+             * directives
+             */
+            module: string;
+            /**
+             * the PyPI distribution name for the package.
+             */
+            distName: string;
+        };
+        dotnet?: {
+            /**
+             * the root namespace under which types will be declared
+             */
+            namespace: string;
+            /**
+             * identifier of the package in the NuGet registry
+             */
+            packageId: string;
+            /**
+             * url of the icon to be shown in the NuGet Gallery
+             */
+            iconUrl?: string;
+            /**
+             * optional suffix that will be appended at the end of the NuGet package's
+             * version field
+             */
+            versionSuffix?: string;
+        };
+    };
+    /**
+     * used to record additional metadata as key-value pairs that will be recorded
+     * as-is into the .jsii assembly file
+     */
+    metadata?: {
+        [key: string]: any;
+    };
+    /**
+     * TypeScript compiler options
+     */
+    tsc?: {
+        outDir?: string;
+        rootDir?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * Structure of jsii module package.json
+ */
+export interface PackageJson {
+    /**
+     * module name for typescript module published to npmjs
+     */
+    name: string;
+    /**
+     * module's current semantic version number
+     */
+    version: string;
+    /**
+     * module's source code repository information
+     */
+    repository: string | {
+        url: string;
+        type?: string;
+        directory?: string;
+    };
+    /**
+     * main module entrypoint file
+     */
+    main: string;
+    /**
+     * module's primary author information
+     */
+    author: string | {
+        name: string;
+        email?: string;
+        url?: string;
+        organization?: boolean;
+    };
+    /**
+     * jsii compiler configuration
+     */
+    jsii: Config;
+    /**
+     * module's built typescript definitions file location
+     */
+    types: string;
+    /**
+     * module's api stability level
+     */
+    stability?: Stability;
+    /**
+     * Run-time dependencies that are private to this assembly
+     */
+    dependencies?: Record<string, string>;
+    /**
+     * Run-time dependencies that will be shared with other assemblies
+     */
+    peerDependencies?: Record<string, string>;
+    /**
+     * Build-time dependencies
+     */
+    devDependencies?: Record<string, string>;
+    bundleDependencies?: string[];
+    bundledDependencies?: string[];
+    [key: string]: unknown;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/node_modules/@jsii/spec/lib/configuration.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=configuration.js.map

package/node_modules/@jsii/spec/lib/index.d.ts

@@ -0,0 +1,7 @@
+export * from './assembly';
+export * from './assembly-utils';
+export * from './configuration';
+export * from './name-tree';
+export * from './redirect';
+export * from './validate-assembly';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@jsii/spec/lib/index.js

@@ -0,0 +1,23 @@
+"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("./assembly"), exports);
+__exportStar(require("./assembly-utils"), exports);
+__exportStar(require("./configuration"), exports);
+__exportStar(require("./name-tree"), exports);
+__exportStar(require("./redirect"), exports);
+__exportStar(require("./validate-assembly"), exports);
+//# sourceMappingURL=index.js.map

package/node_modules/@jsii/spec/lib/name-tree.d.ts

@@ -0,0 +1,60 @@
+import * as spec from './assembly';
+/**
+ * A tree of all names in a module. A node represent a type (terminal)
+ * and may represent another node in the namespace (at the same time).
+ * Therefore, a key of '_' represents a terminal and references the fqn
+ * of the type.
+ *
+ * For example, say we have the following types:
+ *   - aws.ec2.Host
+ *   - aws.ec2.Instance
+ *   - aws.ec2.Instance.Subtype
+ *
+ * the the name tree will look like this:
+ *
+ * module: {
+ *   children: {
+ *     aws: {
+ *       children {
+ *         ec2: {
+ *           children: {
+ *             Host: {
+ *               fqn: 'aws.ec2.Host',
+ *               children: {}
+ *             },
+ *             Instance: {
+ *               fqn: 'aws.ec2.Host',
+ *               children: {
+ *                 Subtype: {
+ *                   fqn: 'aws.ec2.Host.Subtype',
+ *                   children: {}
+ *                 }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ */
+export declare class NameTree {
+    static of(assm: spec.Assembly): NameTree;
+    private _children;
+    private _fqn?;
+    private constructor();
+    /** The children of this node, by name. */
+    get children(): {
+        readonly [name: string]: NameTree;
+    };
+    /** The fully qualified name of the type at this node, if there is one. */
+    get fqn(): string | undefined;
+    /**
+     * Adds a type to this ``NameTree``.
+     *
+     * @param type the type to be added.
+     * @param path the path at which to add the node under this tree.
+     */
+    private register;
+}
+//# sourceMappingURL=name-tree.d.ts.map

package/node_modules/@jsii/spec/lib/name-tree.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameTree = void 0;
+/**
+ * A tree of all names in a module. A node represent a type (terminal)
+ * and may represent another node in the namespace (at the same time).
+ * Therefore, a key of '_' represents a terminal and references the fqn
+ * of the type.
+ *
+ * For example, say we have the following types:
+ *   - aws.ec2.Host
+ *   - aws.ec2.Instance
+ *   - aws.ec2.Instance.Subtype
+ *
+ * the the name tree will look like this:
+ *
+ * module: {
+ *   children: {
+ *     aws: {
+ *       children {
+ *         ec2: {
+ *           children: {
+ *             Host: {
+ *               fqn: 'aws.ec2.Host',
+ *               children: {}
+ *             },
+ *             Instance: {
+ *               fqn: 'aws.ec2.Host',
+ *               children: {
+ *                 Subtype: {
+ *                   fqn: 'aws.ec2.Host.Subtype',
+ *                   children: {}
+ *                 }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ */
+class NameTree {
+    static of(assm) {
+        const nameTree = new NameTree();
+        for (const type of Object.values(assm.types ?? {})) {
+            nameTree.register(type.fqn);
+        }
+        return nameTree;
+    }
+    /* NameTree.of(assembly) should be used. */
+    constructor() {
+        this._children = {};
+    }
+    /** The children of this node, by name. */
+    get children() {
+        return this._children;
+    }
+    /** The fully qualified name of the type at this node, if there is one. */
+    get fqn() {
+        return this._fqn;
+    }
+    /**
+     * Adds a type to this ``NameTree``.
+     *
+     * @param type the type to be added.
+     * @param path the path at which to add the node under this tree.
+     */
+    register(fqn, path = fqn.split('.')) {
+        if (path.length === 0) {
+            this._fqn = fqn;
+        }
+        else {
+            const [head, ...rest] = path;
+            if (!this._children[head]) {
+                this._children[head] = new NameTree();
+            }
+            this._children[head].register(fqn, rest);
+        }
+        return this;
+    }
+}
+exports.NameTree = NameTree;
+//# sourceMappingURL=name-tree.js.map

package/node_modules/@jsii/spec/lib/redirect.d.ts

@@ -0,0 +1,33 @@
+export declare const assemblyRedirectSchema: any;
+declare const SCHEMA = "jsii/file-redirect";
+export interface AssemblyRedirect {
+    readonly schema: typeof SCHEMA;
+    /**
+     * The compression applied to the target file, if any.
+     */
+    readonly compression?: 'gzip';
+    /**
+     * The name of the file the assembly is redirected to.
+     */
+    readonly filename: string;
+}
+/**
+ * Checks whether the provided value is an assembly redirect. This only checks
+ * for presence of the correct value in the `schema` attribute. For full
+ * validation, `validateAssemblyRedirect` should be used instead.
+ *
+ * @param obj the value to be tested.
+ *
+ * @returns `true` if the value is indeed an AssemblyRedirect.
+ */
+export declare function isAssemblyRedirect(obj: unknown): obj is AssemblyRedirect;
+/**
+ * Validates the provided value as an assembly redirect.
+ *
+ * @param obj the value to be tested.
+ *
+ * @returns the validated value.
+ */
+export declare function validateAssemblyRedirect(obj: unknown): AssemblyRedirect;
+export {};
+//# sourceMappingURL=redirect.d.ts.map

package/node_modules/@jsii/spec/lib/redirect.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assemblyRedirectSchema = void 0;
+exports.isAssemblyRedirect = isAssemblyRedirect;
+exports.validateAssemblyRedirect = validateAssemblyRedirect;
+const ajv_1 = require("ajv");
+// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+exports.assemblyRedirectSchema = require('../schema/assembly-redirect.schema.json');
+const SCHEMA = 'jsii/file-redirect';
+/**
+ * Checks whether the provided value is an assembly redirect. This only checks
+ * for presence of the correct value in the `schema` attribute. For full
+ * validation, `validateAssemblyRedirect` should be used instead.
+ *
+ * @param obj the value to be tested.
+ *
+ * @returns `true` if the value is indeed an AssemblyRedirect.
+ */
+function isAssemblyRedirect(obj) {
+    if (typeof obj !== 'object' || obj == null) {
+        return false;
+    }
+    return obj.schema === SCHEMA;
+}
+/**
+ * Validates the provided value as an assembly redirect.
+ *
+ * @param obj the value to be tested.
+ *
+ * @returns the validated value.
+ */
+function validateAssemblyRedirect(obj) {
+    const ajv = new ajv_1.default({
+        allErrors: true,
+    });
+    const validate = ajv.compile(exports.assemblyRedirectSchema);
+    validate(obj);
+    if (validate.errors) {
+        throw new Error(`Invalid assembly redirect:\n * ${ajv.errorsText(validate.errors, {
+            separator: '\n * ',
+            dataVar: 'redirect',
+        })}`);
+    }
+    return obj;
+}
+//# sourceMappingURL=redirect.js.map

package/node_modules/@jsii/spec/lib/validate-assembly.d.ts

@@ -0,0 +1,4 @@
+import { Assembly } from './assembly';
+export declare const schema: any;
+export declare function validateAssembly(obj: any): Assembly;
+//# sourceMappingURL=validate-assembly.d.ts.map

package/node_modules/@jsii/spec/lib/validate-assembly.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+exports.validateAssembly = validateAssembly;
+const ajv_1 = require("ajv");
+// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+exports.schema = require('../schema/jsii-spec.schema.json');
+function validateAssembly(obj) {
+    const ajv = new ajv_1.default({
+        allErrors: true,
+    });
+    const validate = ajv.compile(exports.schema);
+    validate(obj);
+    if (validate.errors) {
+        let descr = '';
+        if (typeof obj.name === 'string' && obj.name !== '') {
+            descr =
+                typeof obj.version === 'string'
+                    ? ` ${obj.name}@${obj.version}`
+                    : ` ${obj.name}`;
+        }
+        throw new Error(`Invalid assembly${descr}:\n * ${ajv.errorsText(validate.errors, {
+            separator: '\n * ',
+            dataVar: 'assembly',
+        })}`);
+    }
+    return obj;
+}
+//# sourceMappingURL=validate-assembly.js.map

package/node_modules/@jsii/spec/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@jsii/spec",
+  "version": "1.119.0",
+  "description": "Specification for jsii assemblies",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Amazon Web Services",
+    "url": "https://aws.amazon.com"
+  },
+  "homepage": "https://github.com/aws/jsii",
+  "bugs": {
+    "url": "https://github.com/aws/jsii/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aws/jsii.git",
+    "directory": "packages/@jsii/spec"
+  },
+  "engines": {
+    "node": ">= 14.17.0"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc --build && bash build-tools/generate-json-schema.sh && yarn lint",
+    "watch": "tsc --build -w",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false NODE_OPTIONS='--disable-warning=ESLintRCWarning' eslint . --ext .js,.ts --ignore-path=.gitignore",
+    "lint:fix": "yarn lint --fix",
+    "test": "jest",
+    "test:update": "jest -u",
+    "package": "package-js"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1"
+  },
+  "devDependencies": {
+    "fs-extra": "^10.1.0",
+    "jsii-build-tools": "^1.119.0",
+    "typescript-json-schema": "^0.65.1"
+  }
+}