@goast/core 0.1.1 → 0.2.1

package/types/lib/utils/string-builder/string-builder.d.ts

@@ -0,0 +1,72 @@
+import { StringBuilderOptions } from './options';
+import { Nullable, SingleOrMultiple } from '../type.utils';
+export type BuilderFn<TBuilder extends StringBuilder> = (builder: TBuilder) => void;
+export type Primitive = string | number | boolean;
+export type AppendParam<TBuilder extends StringBuilder, TAdditionalAppends> = SingleOrMultiple<Primitive | null | undefined | BuilderFn<TBuilder> | TAdditionalAppends | {
+    __type: 'append-value-group';
+    values: AppendParam<TBuilder, TAdditionalAppends>[];
+    separator: string | null;
+}>;
+export declare const AdditionalAppendsSymbol: unique symbol;
+/**
+ * Represents a mutable string of characters.
+ */
+export declare class StringBuilder<TAdditionalAppends = never> {
+    private readonly _options;
+    protected str: string;
+    [AdditionalAppendsSymbol](_: TAdditionalAppends): void;
+    get options(): StringBuilderOptions;
+    /**
+     * Initializes a new instance of the StringBuilder class.
+     * @param options The options.
+     */
+    constructor(options?: Partial<StringBuilderOptions>);
+    /**
+     * 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: string, options?: Partial<StringBuilderOptions>): StringBuilder;
+    /**
+     * 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: AppendParam<StringBuilder, never>, options?: Partial<StringBuilderOptions>): string;
+    protected appendSingle(value: AppendParam<this, TAdditionalAppends>): void;
+    /**
+     * 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: AppendParam<this, TAdditionalAppends>[]): this;
+    /**
+     * Appends one or more strings to the end of the current StringBuilder, followed by a line terminator.
+     * @param value
+     * @returns
+     */
+    appendLine(...value: Nullable<AppendParam<this, TAdditionalAppends>>[]): this;
+    /**
+     * 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: AppendParam<StringBuilder, never>[]): 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: AppendParam<StringBuilder, never>[]): this;
+    /**
+     * Converts the value of this instance to a string.
+     * @returns A string whose value is the same as this instance.
+     */
+    toString(): string;
+    /**
+     * Removes all characters from the current StringBuilder.
+     */
+    clear(): void;
+}

package/types/lib/utils/string-builder/utils.d.ts

@@ -0,0 +1,21 @@
+import { Nullable } from '../type.utils';
+import type { AdditionalAppendsSymbol, AppendParam, BuilderFn, Primitive, StringBuilder } from './string-builder';
+export type BasicAppendValue<TBuilder extends StringBuilder = StringBuilder> = Primitive | BuilderFn<TBuilder> | BasicAppendValueGroup<TBuilder>;
+export type BasicAppendValueGroup<TBuilder extends StringBuilder = StringBuilder> = {
+    __type: 'append-value-group';
+    values: BasicAppendValue<TBuilder>[];
+    separator: string | null;
+};
+export type AppendValue<TBuilder extends StringBuilder = StringBuilder> = NonNullable<AppendParam<TBuilder, Parameters<TBuilder[typeof AdditionalAppendsSymbol]>[0]>>;
+export type AppendValueGroup<TBuilder extends StringBuilder = StringBuilder> = {
+    __type: 'append-value-group';
+    values: AppendValue<TBuilder>[];
+    separator: string | null;
+};
+/** @deprecated Use AppendValue<TBuilder> instead */
+export type TextOrBuilderFn<TBuilder> = string | ((builder: TBuilder) => void);
+export declare function basicAppendValueGroup<TBuilder extends StringBuilder = StringBuilder>(values: Nullable<Nullable<BasicAppendValue<TBuilder>>[]>, separator?: Nullable<string>): BasicAppendValueGroup<TBuilder>;
+export declare function appendValueGroup<TBuilder extends StringBuilder = StringBuilder>(values: Nullable<Nullable<AppendValue<TBuilder>>[]>, separator?: Nullable<string>): AppendValueGroup<TBuilder>;
+export declare function isAppendValue(value: unknown): value is AppendValue<never>;
+export declare function isAppendValueGroup<TBuilder extends StringBuilder = StringBuilder>(value: unknown): value is AppendValueGroup<TBuilder>;
+export declare function concatAppendValues<TBuilder extends StringBuilder = StringBuilder>(...values: AppendValue<TBuilder>[]): AppendValue<TBuilder>;

package/types/lib/utils/string.utils.d.ts

@@ -1,5 +1,11 @@
 import { WordCasing, StringCasing, CamelCaseOptions, PascalCaseOptions, KebabCaseOptions, SnakeCaseOptions, CustomCaseOptions, StringCasingWithOptions } from './string.utils.types';
 import { Nullable } from './type.utils';
+export declare function adjustCasing(a: StringCasing, b: StringCasing): StringCasing;
+export declare function adjustCasing(a: StringCasing | StringCasingWithOptions, b: StringCasing | Partial<StringCasingWithOptions>): StringCasingWithOptions;
+export declare function lowercase<T extends string>(str: T): Lowercase<T>;
+export declare function uppercase<T extends string>(str: T): Uppercase<T>;
+export declare function capitalize<T extends string>(str: T): Capitalize<T>;
+export declare function uncapitalize<T extends string>(str: T): Uncapitalize<T>;
 /**
  * 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.
@@ -104,72 +110,20 @@ export declare function toCustomCase(str: Nullable<string>, options: CustomCaseO
  */
 export declare function escapeRegExp(str: string): string;
 /**
- * Options for the StringBuilder class.
- * @default newLine = os.EOL
+ * 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.
  */
-export type StringBuilderOptions = {
-    readonly newLine: string;
-};
-export declare const defaultStringBuilderOptions: StringBuilderOptions;
-export type BuilderFn<TBuilder extends StringBuilder> = (builder: TBuilder) => void;
-export type TextOrBuilderFn<TBuilder extends StringBuilder> = string | BuilderFn<TBuilder>;
+export declare function spliceString(str: string, start: number, deleteCount: number, insert: string): string;
 /**
- * Represents a mutable string of characters.
+ * Removes leading indentation based on the last line. Also removes the first line if it is empty.
+ * @param str The string to trim.
  */
-export declare class StringBuilder {
-    private readonly _options;
-    private _str;
-    get options(): StringBuilderOptions;
-    /**
-     * Initializes a new instance of the StringBuilder class.
-     * @param options The options.
-     */
-    constructor(options?: Partial<StringBuilderOptions>);
-    /**
-     * 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: string, options?: Partial<StringBuilderOptions>): StringBuilder;
-    /**
-     * 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: (builder: StringBuilder) => void, options?: Partial<StringBuilderOptions>): string;
-    /**
-     * 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: Nullable<TextOrBuilderFn<this>>[]): this;
-    /**
-     * Appends one or more strings to the end of the current StringBuilder, followed by a line terminator.
-     * @param value
-     * @returns
-     */
-    appendLine(...value: Nullable<TextOrBuilderFn<this>>[]): this;
-    /**
-     * 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: Nullable<TextOrBuilderFn<StringBuilder>>[]): 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: Nullable<TextOrBuilderFn<StringBuilder>>[]): this;
-    /**
-     * Converts the value of this instance to a string.
-     * @returns A string whose value is the same as this instance.
-     */
-    toString(): string;
-    /**
-     * Removes all characters from the current StringBuilder.
-     */
-    clear(): void;
-}
+export declare function trimIndent(str: string): string;
+export declare function trimEnd(str: string, includeNewLine?: boolean): string;
+export declare function trimStart(str: string, includeNewLine?: boolean): string;
+export declare function trim(str: string, includeNewLine?: boolean): string;
+export declare function removeStr(str: string, rem: string): string;

package/types/lib/utils/type.utils.d.ts

@@ -1,16 +1,55 @@
-type MergeTwo<T, U> = {
-    [P in Exclude<keyof T, keyof U>]: T[P];
-} & U;
-export type Merge<U extends unknown[]> = U extends [infer A, ...infer R] ? MergeTwo<A, Merge<R>> : {};
+export type Merge<U extends unknown[]> = U extends [infer A, ...infer R] ? A & Merge<R> : {};
 export type OptionalProperties<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type RequiredProperties<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 export type ArrayItem<T> = T extends (infer U)[] ? U : never;
+export type SingleOrMultiple<T> = T | T[];
+export type Single<T> = T extends (infer U)[] ? U : T;
+export type Multiple<T> = T extends (infer U)[] ? U[] : T[];
 export type Nullable<T> = T | null | undefined;
-export interface Constructor<T, TArgs extends any[]> extends Function {
+export interface Constructor<T, TArgs extends any[] = any[]> extends Function {
     new (...args: TArgs): T;
 }
 export type EmptyConstructor<T> = Constructor<T, []>;
 export type FunctionNames<T> = {
     [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
 }[keyof T];
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type ValueOf<T> = T[keyof T];
+export type NonEmptyArray<T> = [T, ...T[]];
+type MustInclude<T, U extends T[]> = [T] extends [ValueOf<U>] ? U : never;
+export declare function stringUnionToArray<T>(): <U extends NonEmptyArray<T>>(...elements: MustInclude<T, U>) => MustInclude<T, U>;
+export type StringSuggestions<T extends string> = T | Omit<string, T>;
+export declare function suggestionsAsString<T>(value: T): T extends StringSuggestions<infer U> ? Exclude<T, StringSuggestions<U>> | string : T;
+export type ParametersWithOverloads<T extends (...args: any[]) => any> = T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+    (...args: infer A3): any;
+    (...args: infer A4): any;
+    (...args: infer A5): any;
+    (...args: infer A6): any;
+} ? A1 | A2 | A3 | A4 | A5 | A6 : T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+    (...args: infer A3): any;
+    (...args: infer A4): any;
+    (...args: infer A5): any;
+} ? A1 | A2 | A3 | A4 | A5 : T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+    (...args: infer A3): any;
+    (...args: infer A4): any;
+} ? A1 | A2 | A3 | A4 : T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+    (...args: infer A3): any;
+} ? A1 | A2 | A3 : T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+} ? A1 | A2 : T extends {
+    (...args: infer A1): any;
+} ? A1 : never;
+type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+export type TupleWithCount<T, N extends number | number[]> = N extends number ? number extends N ? T[] : _TupleOf<T, N, []> : N extends [infer A, ...infer R] ? A extends number ? R extends number[] ? TupleWithCount<T, A> | TupleWithCount<T, R> : never : never : N extends [] ? never : T[];
 export {};