@cdk8s/projen-common 0.0.237 → 0.0.238

package/node_modules/codemaker/README.md

@@ -0,0 +1,120 @@
+# codemaker
+
+Makes code. Well.. just a simple text writer with support for:
+
+ 1. Blocks (indentation/open/close)
+ 2. Supports multiple files (with subdirectories)
+ 3. Exclusion of files
+
+```js
+import { CodeMaker } from 'codemaker'
+
+let maker = new CodeMaker();
+maker.openFile('myfile.js');
+maker.line('first line');
+maker.openBlock('open');
+maker.line('second line');
+maker.closeBlock();
+maker.indent('generic open [');
+maker.line('boom');
+maker.line('bam');
+maker.unindent(']');
+maker.closeFile('myfile.js');
+
+let yourfileRelativePath = './relative/subdirs/are/also/supported/yourfile.js';
+maker.openFile(yourfileRelativePath);
+maker.line('this is your file speaking');
+
+// change indentation and block formatting
+maker.indentation = 10;
+maker.openBlockFormatter = s => `(--- ${s} ---`;
+maker.closeBlockFormatter = s => `--- ${s} ---)`;
+
+maker.openBlock('block1');
+maker.line('block1.line1');
+maker.line('block1.line2');
+maker.openBlock('block2');
+maker.line('block2.line1');
+maker.closeBlock('block2 (close)');
+maker.line('block1.line3');
+maker.closeBlock('block1 (close)');
+
+// closeFile will ensure that you are closing the same file.
+maker.closeFile(yourfileRelativePath);
+
+// files can also be excluded by adding their path to exclude()
+maker.openFile('rel/excluded.txt');
+maker.line('this file will not be emitted in save()');
+maker.closeFile('rel/excluded.txt');
+
+// later in the day
+maker.exclude('rel/excluded.txt');
+
+// this is javascript - you can customize openBlock to whatever
+maker.openBlock = function(s) {
+  this.line(s);
+  this.open('{');
+};
+
+maker.openFile('custom-blocks.cpp');
+maker.openBlock('Block1()');
+maker.line('L1');
+maker.openBlock('Block2()');
+maker.line('L2');
+maker.closeBlock();
+maker.closeBlock();
+maker.closeFile('custom-blocks.cpp');
+
+// returns a sorted list of output files
+let files = await maker.save('/tmp/source-files');
+```
+
+* /tmp/source-files/myfile.js:
+
+```
+first line
+open {
+    second line
+}
+generic open [
+    boom
+    bam
+]
+```
+
+* /tmp/source-files/relative/subdirs/are/also/supported/yourfile.js:
+
+```
+this is your file speaking
+(--- block1 ---
+          block1.line1
+          block1.line2
+          (--- block2 ---
+                    block2.line1
+          --- block2 (close) ---)
+          block1.line3
+--- block1 (close) ---)
+```
+
+* /tmp/source-files/custom-blocks.cpp:
+
+```
+Block1()
+{
+    L1
+    Block2()
+    {
+        L2
+    }
+}
+```
+
+Neat.
+
+Also bundles a couple of case utils from **sindresorhus**:
+
+```js
+maker.toCamelCase(s, ...)
+maker.toPascalCase(s, ...)
+maker.toSnakCase(s, sep = '_')
+```

package/node_modules/codemaker/jest.config.mjs

@@ -0,0 +1,3 @@
+import config from '../../jest.config.mjs';
+
+export default config;

package/node_modules/codemaker/lib/case-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function toCamelCase(...args: string[]): string;
+export declare function toPascalCase(...args: string[]): string;
+export declare function toSnakeCase(s: string, separator?: string): string;
+//# sourceMappingURL=case-utils.d.ts.map

package/node_modules/codemaker/lib/case-utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSnakeCase = exports.toPascalCase = exports.toCamelCase = void 0;
+const camelcase = require("camelcase");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const decamelize = require("decamelize");
+const COMMON_ABBREVIATIONS = ['KiB', 'MiB', 'GiB'];
+function toCamelCase(...args) {
+    return camelcase(args);
+}
+exports.toCamelCase = toCamelCase;
+function toPascalCase(...args) {
+    return camelcase(args, { pascalCase: true });
+}
+exports.toPascalCase = toPascalCase;
+const ABBREV_RE = new RegExp(`(^|[^A-Z])(${COMMON_ABBREVIATIONS.map(regexQuote).join('|')})($|[^a-z])`, 'g');
+function toSnakeCase(s, separator = '_') {
+    // Save common abbrevations
+    s = s.replace(ABBREV_RE, (_, before, abbr, after) => before + ucfirst(abbr.toLowerCase()) + after);
+    return decamelize(s, { separator });
+    function ucfirst(str) {
+        return str.slice(0, 1).toUpperCase() + str.slice(1).toLowerCase();
+    }
+}
+exports.toSnakeCase = toSnakeCase;
+function regexQuote(s) {
+    return s.replace(/[.?*+^$[\]\\(){}|-]/g, '\\$&');
+}
+//# sourceMappingURL=case-utils.js.map

package/node_modules/codemaker/lib/codemaker.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Multi-file text writer with some code-generation features.
+ */
+export declare class CodeMaker {
+    /**
+     * The indentation level of the file.
+     */
+    indentation: number;
+    /**
+     * The character to use for indentation. When setting this to `\t`, consider
+     * also setting `indentation` to `1`.
+     */
+    indentCharacter: ' ' | '\t';
+    private currIndent;
+    private currentFile?;
+    private readonly files;
+    private readonly excludes;
+    constructor({ indentationLevel, indentCharacter, }?: {
+        indentationLevel?: CodeMaker['indentation'];
+        indentCharacter?: CodeMaker['indentCharacter'];
+    });
+    get currentIndentLength(): number;
+    /**
+     * Formats an block open statement.
+     */
+    openBlockFormatter: (s?: string) => string;
+    /**
+     * Formats a block close statement.
+     */
+    closeBlockFormatter: (s?: string) => string | false;
+    /**
+     * Saves all the files created in this code maker.
+     * @param rootDir The root directory for all saved files.
+     * @returns A sorted list of all the files saved (absolute paths).
+     */
+    save(rootDir: string): Promise<string[]>;
+    /**
+     * Sets the name of the current file we are working with.
+     * Note that this doesn't really create a new file (files are only created when save() is called.
+     * Use `closeFile` to close this file.
+     * @param filePath The relative path of the new file.
+     */
+    openFile(filePath: string): void;
+    /**
+     * Indicates that we finished generating the current file.
+     * @param filePath The relative file path (must be the same as one passed to openFile)
+     */
+    closeFile(filePath: string): void;
+    /**
+     * Emits a line into the currently opened file.
+     * Line is emitted with the current level of indentation.
+     * If no arguments are provided, an empty new line is emitted.
+     * @param fmt String format arguments (passed to `util.format`)
+     * @param args String arguments
+     */
+    line(fmt?: string, ...args: string[]): void;
+    /**
+     * Same as `open`.
+     */
+    indent(textBefore?: string): void;
+    /**
+     * Same as `close`.
+     */
+    unindent(textAfter?: string | false): void;
+    /**
+     * Increases the indentation level by `indentation` spaces for the next line.
+     * @param textBefore Text to emit before the newline (i.e. block open).
+     */
+    open(textBefore?: string): void;
+    /**
+     * Decreases the indentation level by `indentation` for the next line.
+     * @param textAfter Text to emit in the line after indentation was decreased.
+     *                  If `false` no line will be emitted at all, but the indent
+     *                  counter will be decremented.
+     */
+    close(textAfter?: string | false): void;
+    /**
+     * Opens a code block. The formatting of the block is determined by `openBlockFormatter`.
+     * @param text The text to pass to the formatter.
+     */
+    openBlock(text: string): void;
+    /**
+     * Closes a code block. The formatting of the block is determined by `closeBlockFormatter`.
+     * @param text The text to pass to the formatter.
+     */
+    closeBlock(text?: string): void;
+    /**
+     * Adds a file to the exclude list. This means this file will not be saved during save().
+     * @param filePath The relative path of the file.
+     */
+    exclude(filePath: string): void;
+    /**
+     * convertsStringToCamelCase
+     */
+    toCamelCase(...args: string[]): string;
+    /**
+     * ConvertsStringToPascalCase
+     */
+    toPascalCase(...args: string[]): string;
+    /**
+     * convert_string_to_snake_case
+     * @param sep Separator (defaults to '_')
+     */
+    toSnakeCase(s: string, sep?: string): string;
+    private makeIndent;
+}
+//# sourceMappingURL=codemaker.d.ts.map

package/node_modules/codemaker/lib/codemaker.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeMaker = void 0;
+const util = require("util");
+const caseutils = require("./case-utils");
+const filebuff_1 = require("./filebuff");
+/**
+ * Multi-file text writer with some code-generation features.
+ */
+class CodeMaker {
+    constructor({ indentationLevel = 4, indentCharacter = ' ', } = {}) {
+        this.currIndent = 0;
+        this.files = new Array();
+        this.excludes = new Array();
+        /**
+         * Formats an block open statement.
+         */
+        this.openBlockFormatter = (s) => `${s} {`;
+        /**
+         * Formats a block close statement.
+         */
+        this.closeBlockFormatter = () => '}';
+        this.indentation = indentationLevel;
+        this.indentCharacter = indentCharacter;
+    }
+    get currentIndentLength() {
+        return this.currIndent * this.indentation;
+    }
+    /**
+     * Saves all the files created in this code maker.
+     * @param rootDir The root directory for all saved files.
+     * @returns A sorted list of all the files saved (absolute paths).
+     */
+    async save(rootDir) {
+        const paths = this.files
+            .filter((file) => !this.excludes.includes(file.filePath))
+            .map((file) => file.save(rootDir));
+        return (await Promise.all(paths)).sort();
+    }
+    /**
+     * Sets the name of the current file we are working with.
+     * Note that this doesn't really create a new file (files are only created when save() is called.
+     * Use `closeFile` to close this file.
+     * @param filePath The relative path of the new file.
+     */
+    openFile(filePath) {
+        if (this.currentFile) {
+            throw new Error(`Cannot open file ${filePath} without closing the previous file ${this.currentFile.filePath}`);
+        }
+        this.currentFile = new filebuff_1.default(filePath);
+    }
+    /**
+     * Indicates that we finished generating the current file.
+     * @param filePath The relative file path (must be the same as one passed to openFile)
+     */
+    closeFile(filePath) {
+        if (!this.currentFile) {
+            throw new Error(`Cannot close file ${filePath}. It was never opened`);
+        }
+        if (this.currentFile.filePath !== filePath) {
+            throw new Error(`Cannot close file ${filePath}. The currently opened file is ${this.currentFile.filePath}`);
+        }
+        this.files.push(this.currentFile);
+        this.currentFile = undefined;
+    }
+    /**
+     * Emits a line into the currently opened file.
+     * Line is emitted with the current level of indentation.
+     * If no arguments are provided, an empty new line is emitted.
+     * @param fmt String format arguments (passed to `util.format`)
+     * @param args String arguments
+     */
+    line(fmt, ...args) {
+        if (!this.currentFile) {
+            throw new Error('Cannot emit source lines without opening a file');
+        }
+        if (fmt) {
+            fmt = this.makeIndent() + fmt;
+            this.currentFile.write(util.format(fmt, ...args));
+        }
+        this.currentFile.write('\n');
+    }
+    /**
+     * Same as `open`.
+     */
+    indent(textBefore) {
+        this.open(textBefore);
+    }
+    /**
+     * Same as `close`.
+     */
+    unindent(textAfter) {
+        this.close(textAfter);
+    }
+    /**
+     * Increases the indentation level by `indentation` spaces for the next line.
+     * @param textBefore Text to emit before the newline (i.e. block open).
+     */
+    open(textBefore) {
+        this.line(textBefore);
+        this.currIndent++;
+    }
+    /**
+     * Decreases the indentation level by `indentation` for the next line.
+     * @param textAfter Text to emit in the line after indentation was decreased.
+     *                  If `false` no line will be emitted at all, but the indent
+     *                  counter will be decremented.
+     */
+    close(textAfter) {
+        this.currIndent--;
+        if (textAfter !== false) {
+            this.line(textAfter);
+        }
+    }
+    /**
+     * Opens a code block. The formatting of the block is determined by `openBlockFormatter`.
+     * @param text The text to pass to the formatter.
+     */
+    openBlock(text) {
+        this.open(this.openBlockFormatter(text));
+    }
+    /**
+     * Closes a code block. The formatting of the block is determined by `closeBlockFormatter`.
+     * @param text The text to pass to the formatter.
+     */
+    closeBlock(text) {
+        this.close(this.closeBlockFormatter(text));
+    }
+    /**
+     * Adds a file to the exclude list. This means this file will not be saved during save().
+     * @param filePath The relative path of the file.
+     */
+    exclude(filePath) {
+        this.excludes.push(filePath);
+    }
+    /**
+     * convertsStringToCamelCase
+     */
+    toCamelCase(...args) {
+        return caseutils.toCamelCase(...args);
+    }
+    /**
+     * ConvertsStringToPascalCase
+     */
+    toPascalCase(...args) {
+        return caseutils.toPascalCase(...args);
+    }
+    /**
+     * convert_string_to_snake_case
+     * @param sep Separator (defaults to '_')
+     */
+    toSnakeCase(s, sep = '_') {
+        return caseutils.toSnakeCase(s, sep);
+    }
+    makeIndent() {
+        const length = this.currentIndentLength;
+        if (length <= 0) {
+            return '';
+        }
+        return this.indentCharacter.repeat(length);
+    }
+}
+exports.CodeMaker = CodeMaker;
+//# sourceMappingURL=codemaker.js.map

package/node_modules/codemaker/lib/filebuff.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Buffers the text of a file for later saving.
+ */
+export default class FileBuffer {
+    readonly filePath: string;
+    private buffer;
+    constructor(filePath: string);
+    write(s: string): void;
+    save(rootDir: string): Promise<string>;
+}
+//# sourceMappingURL=filebuff.d.ts.map

package/node_modules/codemaker/lib/filebuff.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+/**
+ * Buffers the text of a file for later saving.
+ */
+class FileBuffer {
+    constructor(filePath) {
+        this.buffer = '';
+        this.filePath = filePath;
+    }
+    write(s) {
+        this.buffer += s;
+    }
+    async save(rootDir) {
+        // just-in-time require so that this file can be loaded in browsers as well.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports,@typescript-eslint/no-var-requires
+        const fs = require('fs-extra');
+        const fullPath = path.join(rootDir, this.filePath);
+        await fs.mkdirs(path.dirname(fullPath));
+        await fs.writeFile(fullPath, this.buffer);
+        return fullPath;
+    }
+}
+exports.default = FileBuffer;
+//# sourceMappingURL=filebuff.js.map

package/node_modules/codemaker/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './codemaker';
+export * from './case-utils';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/codemaker/lib/index.js

@@ -0,0 +1,19 @@
+"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("./codemaker"), exports);
+__exportStar(require("./case-utils"), exports);
+//# sourceMappingURL=index.js.map

package/node_modules/codemaker/node_modules/camelcase/index.d.ts

@@ -0,0 +1,103 @@
+declare namespace camelcase {
+	interface Options {
+		/**
+		Uppercase the first character: `foo-bar` → `FooBar`.
+
+		@default false
+		*/
+		readonly pascalCase?: boolean;
+
+		/**
+		Preserve the consecutive uppercase characters: `foo-BAR` → `FooBAR`.
+
+		@default false
+		*/
+		readonly preserveConsecutiveUppercase?: boolean;
+
+		/**
+		The locale parameter indicates the locale to be used to convert to upper/lower case according to any locale-specific case mappings. If multiple locales are given in an array, the best available locale is used.
+
+		Setting `locale: false` ignores the platform locale and uses the [Unicode Default Case Conversion](https://unicode-org.github.io/icu/userguide/transforms/casemappings.html#simple-single-character-case-mapping) algorithm.
+
+		Default: The host environment’s current locale.
+
+		@example
+		```
+		import camelCase = require('camelcase');
+
+		camelCase('lorem-ipsum', {locale: 'en-US'});
+		//=> 'loremIpsum'
+		camelCase('lorem-ipsum', {locale: 'tr-TR'});
+		//=> 'loremİpsum'
+		camelCase('lorem-ipsum', {locale: ['en-US', 'en-GB']});
+		//=> 'loremIpsum'
+		camelCase('lorem-ipsum', {locale: ['tr', 'TR', 'tr-TR']});
+		//=> 'loremİpsum'
+		```
+		*/
+		readonly locale?: false | string | readonly string[];
+	}
+}
+
+/**
+Convert a dash/dot/underscore/space separated string to camelCase or PascalCase: `foo-bar` → `fooBar`.
+
+Correctly handles Unicode strings.
+
+@param input - String to convert to camel case.
+
+@example
+```
+import camelCase = require('camelcase');
+
+camelCase('foo-bar');
+//=> 'fooBar'
+
+camelCase('foo_bar');
+//=> 'fooBar'
+
+camelCase('Foo-Bar');
+//=> 'fooBar'
+
+camelCase('розовый_пушистый_единорог');
+//=> 'розовыйПушистыйЕдинорог'
+
+camelCase('Foo-Bar', {pascalCase: true});
+//=> 'FooBar'
+
+camelCase('--foo.bar', {pascalCase: false});
+//=> 'fooBar'
+
+camelCase('Foo-BAR', {preserveConsecutiveUppercase: true});
+//=> 'fooBAR'
+
+camelCase('fooBAR', {pascalCase: true, preserveConsecutiveUppercase: true}));
+//=> 'FooBAR'
+
+camelCase('foo bar');
+//=> 'fooBar'
+
+console.log(process.argv[3]);
+//=> '--foo-bar'
+camelCase(process.argv[3]);
+//=> 'fooBar'
+
+camelCase(['foo', 'bar']);
+//=> 'fooBar'
+
+camelCase(['__foo__', '--bar'], {pascalCase: true});
+//=> 'FooBar'
+
+camelCase(['foo', 'BAR'], {pascalCase: true, preserveConsecutiveUppercase: true})
+//=> 'FooBAR'
+
+camelCase('lorem-ipsum', {locale: 'en-US'});
+//=> 'loremIpsum'
+```
+*/
+declare function camelcase(
+	input: string | readonly string[],
+	options?: camelcase.Options
+): string;
+
+export = camelcase;