@goast/core 0.4.0-beta4 → 0.4.1

package/esm/src/utils/source-builder.js

@@ -0,0 +1,447 @@
+import { isNullish } from './common.utils.js';
+import { evalCondition } from './condition.js';
+import { defaultStringBuilderOptions } from './string-builder/options.js';
+import { StringBuilder } from './string-builder/string-builder.js';
+import { removeStr, trimEnd } from './string.utils.js';
+/**
+ * Default options for the `SourceBuilder` class.
+ */
+export const defaultSourceBuilderOptions = {
+    ...defaultStringBuilderOptions,
+    indent: { type: 'spaces', count: 2 },
+};
+/**
+ * Represents an in-memory source file.
+ */
+export class SourceBuilder extends StringBuilder {
+    /**
+     * Gets the options used by this instance.
+     */
+    get options() {
+        return this.__options;
+    }
+    /**
+     * Initializes a new instance of the SourceBuilder class.
+     * @param options The options to use for this instance.
+     */
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "__options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_indentString", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_isLineIndented", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_isLastLineEmpty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "_isCurrentLineEmpty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "_linePrefixNodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.__options = { ...defaultSourceBuilderOptions, ...options };
+        this._indentString = this.__options.indent.type === 'tabs' ? '\t' : ' '.repeat(this.__options.indent.count);
+    }
+    /**
+     * Creates a new instance of the SourceBuilder class from a string.
+     * @param str The string to use as the initial content of the builder.
+     * @param options The options to use for this instance.
+     * @returns A new instance of the SourceBuilder class.
+     */
+    static fromString(str, options) {
+        const builder = new SourceBuilder(options);
+        builder.append(str);
+        return builder;
+    }
+    /**
+     * Builds a string using a callback function that receives a `SourceBuilder` instance.
+     * @param buildAction The callback function that receives a `SourceBuilder` instance to build the string.
+     * @param options The options to use for the `SourceBuilder` instance.
+     * @returns The string built by the `SourceBuilder` instance.
+     */
+    static build(buildAction, options) {
+        const builder = new SourceBuilder(options);
+        builder.append(buildAction);
+        return builder.toString();
+    }
+    appendSingle(value) {
+        var _a;
+        if (isNullish(value))
+            return;
+        if (Array.isArray(value)) {
+            for (const part of value) {
+                this.appendSingle(part);
+            }
+            return;
+        }
+        if (typeof value === 'function') {
+            value(this);
+            return;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            value = value.toString();
+        }
+        if (typeof value === 'object' && value !== null && '__type' in value && value.__type === 'append-value-group') {
+            this.forEach(value.values, (builder, part) => builder.append(part), { separator: (_a = value.separator) !== null && _a !== void 0 ? _a : undefined });
+            return;
+        }
+        if (typeof value !== 'string') {
+            return;
+        }
+        let lineStartIndex = 0;
+        for (let i = 0; i < value.length; i++) {
+            if (value[i] === '\r')
+                continue;
+            if (value[i] === '\n') {
+                let lineLength = i - lineStartIndex;
+                for (let j = i; j > 0 && value[j - 1] === '\r'; j--) {
+                    lineLength--;
+                }
+                if (lineLength > 0) {
+                    if (!this._isLineIndented) {
+                        this.appendIndent();
+                    }
+                    this.str += removeStr(value.substring(lineStartIndex, i), '\r');
+                }
+                this._isLastLineEmpty = this._isCurrentLineEmpty;
+                if (this._isCurrentLineEmpty && this._linePrefixNodes.some((x) => x.kind !== 'indent')) {
+                    this.appendIndent();
+                }
+                this.str = trimEnd(this.str, false) + '\n';
+                this._isLineIndented = false;
+                this._isCurrentLineEmpty = true;
+                lineStartIndex = i + 1;
+            }
+            if (value[i] !== '\r' && value[i] !== '\n' && value[i] !== ' ' && value[i] !== '\t') {
+                this._isCurrentLineEmpty = false;
+            }
+        }
+        if (!this._isLineIndented && lineStartIndex < value.length) {
+            this.appendIndent();
+            this._isLineIndented = true;
+        }
+        this.str += removeStr(value.substring(lineStartIndex), '\r');
+    }
+    /**
+     * Appends one or more strings to the end of the current SourceBuilder if the specified condition is true.
+     * @param condition The condition to check before appending the specified value.
+     * @param value The string(s) to append.
+     * @returns The current SourceBuilder.
+     */
+    appendIf(condition, ...value) {
+        if (evalCondition(condition)) {
+            return this.append(...value);
+        }
+        return this;
+    }
+    /**
+     * Appends one or more strings to the end of the current SourceBuilder, followed by a line terminator.
+     * @param value The string(s) to append.
+     * @returns The current SourceBuilder.
+     */
+    appendLine(...value) {
+        return this.append(...value, '\n');
+    }
+    /**
+     * Appends one or more strings to the end of the current SourceBuilder, followed by a line terminator, if the specified condition is true.
+     * @param condition The condition to check before appending the specified value.
+     * @param value The string(s) to append.
+     * @returns The current SourceBuilder.
+     */
+    appendLineIf(condition, ...value) {
+        if (evalCondition(condition)) {
+            return this.appendLine(...value);
+        }
+        return this;
+    }
+    /**
+     * Appends the specified values to this source builder with the specified line prefix.
+     * @param {string} prefix - The line prefix to use.
+     * @param {...(string|null|undefined)} value - The values to append.
+     * @returns {SourceBuilder} This source builder instance.
+     */
+    appendWithLinePrefix(prefix, ...value) {
+        this._linePrefixNodes.push({ chars: prefix, kind: 'prefix' });
+        try {
+            this.append(...value);
+        }
+        finally {
+            this._linePrefixNodes.pop();
+        }
+        return this;
+    }
+    /**
+     * Appends the specified values to this source builder as a new line with the specified line prefix.
+     * @param {string} prefix - The line prefix to use.
+     * @param {...(string|null|undefined)} value - The values to append.
+     * @returns {SourceBuilder} This source builder instance.
+     */
+    appendLineWithLinePrefix(prefix, ...value) {
+        return this.appendWithLinePrefix(prefix, ...value, '\n');
+    }
+    /**
+     * Prepends one or more strings to the beginning of the current SourceBuilder if the specified condition is true.
+     * @param condition The condition to check before prepending the specified value.
+     * @param value The string(s) to prepend.
+     * @returns The current SourceBuilder.
+     */
+    prependIf(condition, ...value) {
+        if (evalCondition(condition)) {
+            this.prepend(...value);
+        }
+        return this;
+    }
+    /**
+     * Prepends one or more strings to the beginning of the current SourceBuilder, followed by a line terminator, if the specified condition is true.
+     * @param condition The condition to check before appending the specified value.
+     * @param value The string(s) to prepend.
+     * @returns The current SourceBuilder.
+     */
+    prependLineIf(condition, ...value) {
+        if (evalCondition(condition)) {
+            this.prependLine(...value);
+        }
+        return this;
+    }
+    /**
+     * Ensures that the current line and the one before is empty or consists only of whitespace characters.
+     * @returns A reference to this instance.
+     */
+    ensurePreviousLineEmpty() {
+        if (!this._isCurrentLineEmpty) {
+            this.appendLine();
+        }
+        if (!this._isLastLineEmpty) {
+            this.appendLine();
+        }
+        return this;
+    }
+    /**
+     * Ensures that the current line is empty or consists only of whitespace characters.
+     * @returns A reference to this instance.
+     */
+    ensureCurrentLineEmpty() {
+        if (!this._isCurrentLineEmpty) {
+            this.appendLine();
+        }
+        return this;
+    }
+    /**
+     * Pretends that the current line and the one before is empty or consists only of whitespace characters.
+     * @returns A reference to this instance.
+     */
+    pretendPreviousLineEmpty() {
+        this._isLastLineEmpty = true;
+        this._isCurrentLineEmpty = true;
+        return this;
+    }
+    /**
+     * Pretends that the current line is empty or consists only of whitespace characters.
+     * @returns A reference to this instance.
+     */
+    pretendCurrentLineEmpty() {
+        this._isCurrentLineEmpty = true;
+        return this;
+    }
+    /**
+     * Inserts specified content if the specified condition is true.
+     * @param condition The condition to check before inserting content.
+     * @param builderFn The function to add content if the condition is true.
+     * @param elseBuilderFn The function to add content if the condition is false.
+     * @returns A reference to this instance.
+     */
+    if(condition, builderFn, elseBuilderFn) {
+        return evalCondition(condition) ? this.append(builderFn) : this.append(elseBuilderFn);
+    }
+    switch(value, cases, defaultBuilderFn, equals) {
+        var _a;
+        if ((typeof value === 'string' || typeof value === 'number') && !Array.isArray(cases)) {
+            return this.append((_a = cases[value]) !== null && _a !== void 0 ? _a : defaultBuilderFn);
+        }
+        else if (Array.isArray(cases)) {
+            for (const c of cases) {
+                if (equals ? equals(value, c.case) : value === c.case) {
+                    return this.append(c.value);
+                }
+            }
+            return this.append(defaultBuilderFn);
+        }
+        return this;
+    }
+    /**
+     * Adds one indentation level. If the current line already contains characters, only subsequent lines are affected.
+     * @param builderFn The function to add indented content or the content itself.
+     * @param condition The condition to check before adding indentation.
+     * @returns A reference to this instance.
+     */
+    indent(value) {
+        this._linePrefixNodes.push({ chars: this._indentString, kind: 'indent' });
+        try {
+            this.append(value);
+        }
+        finally {
+            this._linePrefixNodes.pop();
+        }
+        return this;
+    }
+    /**
+     * Adds one indentation level if the specified condition is true. If the current line already contains characters, only subsequent lines are affected.
+     * @param builderFn The function to add indented content or the content itself.
+     * @param condition The condition to check before adding indentation.
+     * @returns A reference to this instance.
+     */
+    indentIf(condition, value) {
+        return evalCondition(condition) ? this.indent(value) : this.append(value);
+    }
+    /**
+     * Adds parentheses around the specified content.
+     * @param brackets The brackets to use.
+     * @param value The function to add content inside parentheses or one string that should be parenthesized.
+     * @param options Options for the parentheses.
+     * @returns A reference to this instance.
+     */
+    parenthesize(brackets, value, options) {
+        var _a, _b, _c, _d, _e, _f;
+        const multiline = (_a = options === null || options === void 0 ? void 0 : options.multiline) !== null && _a !== void 0 ? _a : false;
+        const indent = (_b = options === null || options === void 0 ? void 0 : options.indent) !== null && _b !== void 0 ? _b : true;
+        const pretendEmpty = (_c = options === null || options === void 0 ? void 0 : options.pretendEmpty) !== null && _c !== void 0 ? _c : true;
+        if (multiline) {
+            this.appendLine((_d = brackets[0]) !== null && _d !== void 0 ? _d : '');
+        }
+        else {
+            this.append((_e = brackets[0]) !== null && _e !== void 0 ? _e : '');
+        }
+        if (pretendEmpty)
+            this.pretendPreviousLineEmpty();
+        if (indent !== false) {
+            this.indent(value);
+        }
+        else {
+            this.append(value);
+        }
+        if (multiline)
+            this.ensureCurrentLineEmpty();
+        this.append((_f = brackets[1]) !== null && _f !== void 0 ? _f : '');
+        return this;
+    }
+    /**
+     * Adds parentheses around the specified content if the specified condition is true.
+     * @param condition The condition to check before adding parentheses.
+     * @param brackets The brackets to use.
+     * @param value The function to add content inside parentheses or one string that should be parenthesized.
+     * @param options Options for the parentheses.
+     * @returns A reference to this instance.
+     */
+    parenthesizeIf(condition, brackets, value, options) {
+        if (evalCondition(condition)) {
+            return this.parenthesize(brackets, value, options);
+        }
+        else if (options === null || options === void 0 ? void 0 : options.indent) {
+            return this.indent(value);
+        }
+        else {
+            return this.append(value);
+        }
+    }
+    /**
+     * Adds content for each item in the specified array.
+     * @param items The items to add content for.
+     * @param builderFn The function to add content for each item.
+     * @param options The options for the loop.
+     * @returns A reference to this instance.
+     */
+    forEach(items, builderFn, options) {
+        var _a;
+        const condition = (_a = options === null || options === void 0 ? void 0 : options.condition) !== null && _a !== void 0 ? _a : true;
+        if ((options === null || options === void 0 ? void 0 : options.condition) === false)
+            return this;
+        const seperator = options === null || options === void 0 ? void 0 : options.separator;
+        let previousIndex = -1;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        let previousItem = undefined;
+        let index = 0;
+        for (const item of items) {
+            if (evalCondition(condition, item)) {
+                if (previousIndex >= 0 && seperator) {
+                    if (typeof seperator === 'string') {
+                        this.append(seperator);
+                    }
+                    else {
+                        seperator(this, previousItem, item, previousIndex, index);
+                    }
+                }
+                builderFn(this, item, index);
+                previousIndex = index;
+                previousItem = item;
+            }
+            index++;
+        }
+        return this;
+    }
+    forEachIf(condition, items, builderFn, options) {
+        if (evalCondition(condition)) {
+            return this.forEach(items, builderFn, options);
+        }
+        return this;
+    }
+    appendSeparated(items, separator) {
+        return this.forEach(items, (builder, item) => builder.append(item), { separator });
+    }
+    appendSeparatedIf(condition, items, separator) {
+        if (evalCondition(condition)) {
+            return this.appendSeparated(items, separator);
+        }
+        return this;
+    }
+    appendIndent() {
+        this.str += this._linePrefixNodes.map((n) => n.chars).join('');
+    }
+}
+function _builderTemplate(template, ...substitutions) {
+    return (b) => {
+        var _a, _b;
+        let lastLine = undefined;
+        for (let i = template.length - 1; i >= 0; i--) {
+            if (template[i].includes('\n')) {
+                lastLine = template[i];
+                break;
+            }
+        }
+        const indent = (_b = (_a = lastLine === null || lastLine === void 0 ? void 0 : lastLine.match(/\n( *).*$/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
+        const regex = new RegExp(`\\n {0,${indent.length}}`, 'g');
+        for (let i = 0; i < template.length; i++) {
+            b.append(template[i].replace(regex, '\n'));
+            if (i < substitutions.length)
+                b.append(substitutions[i]);
+        }
+    };
+}
+const _builderTemplateExtensions = {
+    indent: (template, ...substitutions) => {
+        return (b) => b.indent(_builderTemplate(template, ...substitutions));
+    },
+};
+export const builderTemplate = Object.assign(_builderTemplate, _builderTemplateExtensions);

package/esm/src/utils/source-builder.test.d.ts

@@ -0,0 +1,2 @@
+import "../../_dnt.test_polyfills.js";
+//# sourceMappingURL=source-builder.test.d.ts.map

package/esm/src/utils/source-builder.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-builder.test.d.ts","sourceRoot":"","sources":["../../../src/src/utils/source-builder.test.ts"],"names":[],"mappings":"AAAA,OAAO,8BAA8B,CAAC"}