@goast/core 0.1.0 → 0.2.0

package/cjs/lib/utils/string.utils.js

@@ -1,8 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringBuilder = exports.defaultStringBuilderOptions = exports.escapeRegExp = exports.toCustomCase = exports.toSnakeCase = exports.toKebabCase = exports.toPascalCase = exports.toCamelCase = exports.toCasing = exports.wordToCasing = exports.getWords = void 0;
-const os_1 = require("os");
+exports.removeStr = exports.trim = exports.trimStart = exports.trimEnd = exports.trimIndent = exports.spliceString = exports.escapeRegExp = exports.toCustomCase = exports.toSnakeCase = exports.toKebabCase = exports.toPascalCase = exports.toCamelCase = exports.toCasing = exports.wordToCasing = exports.getWords = exports.uncapitalize = exports.capitalize = exports.uppercase = exports.lowercase = exports.adjustCasing = void 0;
 const common_utils_1 = require("./common.utils");
+function adjustCasing(a, b) {
+    if (typeof a === 'string') {
+        if (typeof b === 'string') {
+            return b;
+        }
+        else {
+            return Object.assign({ casing: a }, b);
+        }
+    }
+    else if (typeof b === 'string') {
+        return Object.assign(Object.assign({}, a), { casing: b });
+    }
+    else {
+        return Object.assign(Object.assign({}, a), b);
+    }
+}
+exports.adjustCasing = adjustCasing;
+function lowercase(str) {
+    return str.toLowerCase();
+}
+exports.lowercase = lowercase;
+function uppercase(str) {
+    return str.toUpperCase();
+}
+exports.uppercase = uppercase;
+function capitalize(str) {
+    return (str.charAt(0).toUpperCase() + str.slice(1));
+}
+exports.capitalize = capitalize;
+function uncapitalize(str) {
+    return (str.charAt(0).toLowerCase() + str.slice(1));
+}
+exports.uncapitalize = uncapitalize;
 /**
  * Gets the words from a string. Words are separated by capital letters. Leading numbers are removed. Non-alphanumerical characters are removed and interpreted as word seperators. Multiple uppercase letters are interpreted as one word.
  * @param str The string to get the words from.
@@ -230,112 +262,96 @@ function escapeRegExp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 exports.escapeRegExp = escapeRegExp;
-exports.defaultStringBuilderOptions = {
-    newLine: os_1.EOL,
-};
 /**
- * Represents a mutable string of characters.
+ * Removes characters from a string and, if necessary, inserts new characters in their place, returning the spliced string.
+ * @param str The string to splice.
+ * @param start The index at which to start changing the string.
+ * @param deleteCount The number of characters to remove.
+ * @param insert The string to insert.
+ * @returns The spliced string.
  */
-class StringBuilder {
-    get options() {
-        return this._options;
-    }
-    /**
-     * Initializes a new instance of the StringBuilder class.
-     * @param options The options.
-     */
-    constructor(options) {
-        this._str = '';
-        this._options = Object.assign(Object.assign({}, exports.defaultStringBuilderOptions), options);
-    }
-    /**
-     * Creates a new StringBuilder instance and appends the specified string to it.
-     * @param str The string to append.
-     * @param options The options.
-     * @returns A new StringBuilder instance.
-     */
-    static fromString(str, options) {
-        const builder = new StringBuilder(options);
-        builder.append(str);
-        return builder;
-    }
-    /**
-     * Builds a string using a StringBuilder build action.
-     * @param buildAction The build action to perform on the StringBuilder instance.
-     * @param options The options for the StringBuilder instance.
-     * @returns The built string.
-     */
-    static build(buildAction, options) {
-        const builder = new StringBuilder(options);
-        buildAction(builder);
-        return builder.toString();
-    }
-    /**
-     * Appends one or more strings to the end of the current StringBuilder.
-     * @param value The string(s) to append.
-     * @returns The current StringBuilder.
-     */
-    append(...value) {
-        for (const part of value) {
-            if (!part)
-                continue;
-            if (typeof part === 'string') {
-                this._str += part;
-            }
-            else {
-                part(this);
-            }
-        }
-        return this;
-    }
-    /**
-     * Appends one or more strings to the end of the current StringBuilder, followed by a line terminator.
-     * @param value
-     * @returns
-     */
-    appendLine(...value) {
-        return this.append(...value, this._options.newLine);
-    }
-    /**
-     * Prepends one or more strings to the beginning of the current StringBuilder.
-     * @param value The string(s) to prepend.
-     * @returns The current StringBuilder.
-     */
-    prepend(...value) {
-        for (const part of value.reverse()) {
-            if ((0, common_utils_1.isNullish)(part))
-                continue;
-            if (typeof part === 'function') {
-                const builder = new StringBuilder(this.options);
-                part(builder);
-                this._str = builder.toString() + this._str;
-            }
-            else if (part.length > 0) {
-                this._str = part + this._str;
-            }
-        }
-        return this;
-    }
-    /**
-     * Prepends one or more strings to the beginning of the current StringBuilder, followed by a line terminator.
-     * @param value The string(s) to prepend.
-     * @returns The current StringBuilder.
-     */
-    prependLine(...value) {
-        return this.prepend(...value, this._options.newLine);
-    }
-    /**
-     * Converts the value of this instance to a string.
-     * @returns A string whose value is the same as this instance.
-     */
-    toString() {
-        return this._str;
-    }
-    /**
-     * Removes all characters from the current StringBuilder.
-     */
-    clear() {
-        this._str = '';
+function spliceString(str, start, deleteCount, insert) {
+    return str.slice(0, start) + insert + str.slice(start + deleteCount);
+}
+exports.spliceString = spliceString;
+/**
+ * Removes leading indentation based on the last line. Also removes the first line if it is empty.
+ * @param str The string to trim.
+ */
+function trimIndent(str) {
+    var _a, _b;
+    const indent = (_b = (_a = str.match(/\n( *).*$/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
+    if (indent.length === 0)
+        return str;
+    return str.replace(/^\r?\n/, '').replace(new RegExp(`^ {0,${indent.length}}`, 'gm'), '');
+}
+exports.trimIndent = trimIndent;
+function isNonLineBreakWhitespaceChar(char) {
+    return (char === ' ' ||
+        char === '\t' ||
+        char === '\f' ||
+        char === '\v' ||
+        char === '\u00a0' ||
+        char === '\u1680' ||
+        char === '\u2000' ||
+        char === '\u2001' ||
+        char === '\u2002' ||
+        char === '\u2003' ||
+        char === '\u2004' ||
+        char === '\u2005' ||
+        char === '\u2006' ||
+        char === '\u2007' ||
+        char === '\u2008' ||
+        char === '\u2009' ||
+        char === '\u200a' ||
+        char === '\u2028' ||
+        char === '\u2029' ||
+        char === '\u202f' ||
+        char === '\u205f' ||
+        char === '\u3000' ||
+        char === '\ufeff');
+}
+function trimEnd(str, includeNewLine = true) {
+    if (includeNewLine)
+        return str.trimEnd();
+    let i = str.length;
+    for (; isNonLineBreakWhitespaceChar(str[i - 1]); i--)
+        ;
+    return str.substring(0, i);
+}
+exports.trimEnd = trimEnd;
+function trimStart(str, includeNewLine = true) {
+    if (includeNewLine)
+        return str.trimStart();
+    let i = 0;
+    for (; isNonLineBreakWhitespaceChar(str[i]); i++)
+        ;
+    return str.substring(i);
+}
+exports.trimStart = trimStart;
+function trim(str, includeNewLine = true) {
+    if (includeNewLine)
+        return str.trim();
+    let s = 0;
+    for (; isNonLineBreakWhitespaceChar(str[s]); s++)
+        ;
+    let e = str.length;
+    for (; isNonLineBreakWhitespaceChar(str[e - 1]); e--)
+        ;
+    return str.substring(s, e);
+}
+exports.trim = trim;
+function removeStr(str, rem) {
+    let i = str.indexOf(rem);
+    if (i === -1)
+        return str;
+    let result = '';
+    let s = 0;
+    while (i !== -1) {
+        result += str.substring(s, i);
+        s = i + rem.length;
+        i = str.indexOf(rem, s);
     }
+    return result + str.substring(s);
 }
-exports.StringBuilder = StringBuilder;
+exports.removeStr = removeStr;

package/cjs/lib/utils/type.utils.js

@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestionsAsString = exports.stringUnionToArray = void 0;
+function stringUnionToArray() {
+    return (...elements) => elements;
+}
+exports.stringUnionToArray = stringUnionToArray;
+function suggestionsAsString(value) {
+    return value;
+}
+exports.suggestionsAsString = suggestionsAsString;

package/esm/index.js

@@ -1,3 +1,4 @@
+export * from './lib/ast';
 export * from './lib/codegen';
 export * from './lib/parse';
 export * from './lib/transform';

package/esm/lib/ast/index.js

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

package/esm/lib/ast/node.js

@@ -0,0 +1,23 @@
+const NODE_HISTORY_SYMBOL = Symbol('node-history');
+export class AstNode {
+    constructor(options) {
+        var _a;
+        this.inject = (_a = options.inject) !== null && _a !== void 0 ? _a : {};
+    }
+    write(builder) {
+        let history = builder[NODE_HISTORY_SYMBOL];
+        if (!history) {
+            history = [];
+            builder[NODE_HISTORY_SYMBOL] = history;
+        }
+        history.push(this);
+        builder.append(this.inject.before);
+        this.onWrite(builder);
+        builder.append(this.inject.after);
+        history.pop();
+    }
+    getParentNode(builder) {
+        const history = builder[NODE_HISTORY_SYMBOL];
+        return history === null || history === void 0 ? void 0 : history.at(-2);
+    }
+}

package/esm/lib/parse/deref-proxy.js

@@ -10,16 +10,22 @@ class DerefProxyHandler {
         this._overwrittenValues = {};
     }
     get(target, prop) {
-        var _a, _b, _c;
+        var _a;
         if (prop === '$ref') {
             return this._ref;
         }
         else if (prop === '$src') {
             return this._source;
         }
-        return ((_b = (_a = this._overwrittenValues[prop]) !== null && _a !== void 0 ? _a : target[prop]) !== null && _b !== void 0 ? _b : (propertiesNotDerivedFromRef.includes(prop)
+        if (this._overwrittenValues[prop] !== undefined) {
+            return this._overwrittenValues[prop];
+        }
+        if (target[prop] !== undefined) {
+            return target[prop];
+        }
+        return propertiesNotDerivedFromRef.includes(prop)
             ? undefined
-            : (_c = this._ref) === null || _c === void 0 ? void 0 : _c[prop]));
+            : (_a = this._ref) === null || _a === void 0 ? void 0 : _a[prop];
     }
     set(target, prop, value) {
         if (prop === '$ref' && (typeof value === 'object' || typeof value === 'undefined')) {

package/esm/lib/parse/parser.js

@@ -53,7 +53,7 @@ export class OpenApiParser {
             });
             existingDocument.dereferencedComponents.set(path, result);
             if (value.$ref) {
-                result.$ref = yield this.resolveReference(file, value);
+                result.$ref = (yield this.resolveReference(file, value));
             }
             for (const key of Object.keys(value)) {
                 if (key === '$ref')

package/esm/lib/transform/transform-endpoint.js

@@ -141,7 +141,7 @@ function transformResponse(context, response, status) {
         $src: Object.assign(Object.assign({}, response.$src), { component: response }),
         $ref: ref,
         id: context.idGenerator.generateId('response'),
-        statusCode: Number(status),
+        statusCode: Number(status) || undefined,
         description: response.description,
         headers: transformHeaders(context, response.headers),
         contentOptions: transformContent(context, response.content),

package/esm/lib/transform/transform-schema.js

@@ -14,14 +14,14 @@ export function transformSchema(context, schema) {
     if (existing)
         return existing;
     let kind = determineSchemaKind(schema);
-    let nullable = false;
+    let nullable = kind === 'null';
     if (kind === 'multi-type') {
         const types = schema.type;
         let isSingleType = types.length === 1;
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        if (types.length === 2 && (types.includes('null') || types.includes(null))) {
+        if (types.includes('null') || types.includes(null)) {
             nullable = true;
-            isSingleType = true;
+            isSingleType = types.length === 2;
         }
         if (isSingleType) {
             const newType = types.filter((t) => t !== 'null' && t !== null)[0];
@@ -29,6 +29,9 @@ export function transformSchema(context, schema) {
             schema.type = newType;
             kind = determineSchemaKind(schema);
         }
+        else {
+            schema.type = types.filter((t) => t !== 'null' && t !== null);
+        }
     }
     const id = context.idGenerator.generateId('schema');
     const nameInfo = determineSchemaName(schema, id);
@@ -150,7 +153,9 @@ function resolveDescriminatorMapping(context, schema) {
     for (const key of Object.keys(discriminator.mapping)) {
         const mappedSchemaRef = discriminator.mapping[key];
         const mappedSchema = transformSchema(context, mappedSchemaRef);
-        schema.discriminator.mapping[key] = mappedSchema;
-        mappedSchema.inheritedSchemas.push(schema);
+        if (schema.discriminator) {
+            schema.discriminator.mapping[key] = mappedSchema;
+            mappedSchema.inheritedSchemas.push(schema);
+        }
     }
 }

package/esm/lib/utils/array.utils.js

@@ -0,0 +1,7 @@
+export function removeItems(array, predicate) {
+    for (let i = array.length - 1; i >= 0; i--) {
+        if (predicate(array[i])) {
+            array.splice(i, 1);
+        }
+    }
+}

package/esm/lib/utils/class.utils.js

@@ -0,0 +1,27 @@
+export function classifyArray(items, classification) {
+    const result = { rest: [] };
+    for (const key in classification) {
+        result[key] = [];
+    }
+    for (const item of items) {
+        let classified = false;
+        for (const key in classification) {
+            const type = classification[key];
+            if (item instanceof type) {
+                result[key].push(item);
+                classified = true;
+                break;
+            }
+        }
+        if (!classified) {
+            result.rest.push(item);
+        }
+    }
+    return result;
+}
+export function isInstanceOf(item, type) {
+    return item instanceof type;
+}
+export function getIsInstanceOf(type) {
+    return (item) => item instanceof type;
+}

package/esm/lib/utils/common.utils.js

@@ -4,3 +4,67 @@ export function isNullish(value) {
 export function notNullish(value) {
     return !isNullish(value);
 }
+export function concatSingleOrMultiple(...values) {
+    if (values.length === 1) {
+        return values[0];
+    }
+    const result = [];
+    for (const value of values) {
+        if (Array.isArray(value)) {
+            result.push(...value);
+        }
+        else {
+            result.push(value);
+        }
+    }
+    return result;
+}
+export function isIterable(value) {
+    return typeof value === 'object' && value !== null && Symbol.iterator in value;
+}
+export function toArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (isIterable(value)) {
+        return Array.from(value);
+    }
+    return [value];
+}
+export function modify(value, callback) {
+    if (notNullish(value)) {
+        callback(value);
+    }
+    return value;
+}
+export function run(value, callback) {
+    callback(value);
+    return value;
+}
+export function transform(value, callback) {
+    return callback(value);
+}
+export function modifyEach(values, callback) {
+    for (const value of values) {
+        if (notNullish(value)) {
+            callback(value);
+        }
+    }
+    return values;
+}
+export function runEach(values, callback) {
+    for (const value of values) {
+        callback(value);
+    }
+    return values;
+}
+export function transformEach(values, callback) {
+    const result = [];
+    for (const value of values) {
+        result.push(callback(value));
+    }
+    return result;
+}
+export function asVoid(_) {
+    // Do nothing
+}

package/esm/lib/utils/error.utils.js

@@ -0,0 +1,3 @@
+export function throwExp(message) {
+    throw new Error(message);
+}

package/esm/lib/utils/index.js

@@ -1,10 +1,14 @@
+export * from './array.utils';
+export * from './class.utils';
 export * from './common.utils';
 export * from './endpoint.utils';
+export * from './error.utils';
 export * from './factory';
 export * from './generator.utils';
 export * from './object.utils';
 export * from './schema.utils';
 export * from './source-builder';
+export * from './string-builder';
 export * from './string.utils';
 export * from './string.utils.types';
 export * from './type.utils';

package/esm/lib/utils/object.utils.js

@@ -1,5 +1,9 @@
-export function createOverwriteProxy(target) {
-    return new Proxy(target, new OverwriteProxyHandler());
+export function createOverwriteProxy(target, values) {
+    const proxy = new Proxy(target, new OverwriteProxyHandler());
+    if (values) {
+        Object.assign(proxy, values);
+    }
+    return proxy;
 }
 class OverwriteProxyHandler {
     constructor() {

package/esm/lib/utils/schema.utils.js

@@ -33,7 +33,8 @@ function collectSubSchemaProperties(subSchemas, properties, required, optional)
     }
 }
 function hasInvalidSubSchema(subSchemas) {
-    return subSchemas.some((x) => x.kind !== 'object' && (x.kind !== 'combined' || (!hasInvalidSubSchema(x.allOf) && !hasInvalidSubSchema(x.anyOf))));
+    return subSchemas.some((x) => x.kind !== 'object' &&
+        (x.kind !== 'combined' || (!hasInvalidSubSchema(x.allOf) && !hasInvalidSubSchema(x.anyOf))));
 }
 /**
  * Retrieves the first schema reference and the reference chain of a given schema that