@zoodogood/utils 1.0.4 → 1.0.6-change.694

package/lib/discordjs/mod.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Create a message object for Discord.
+ *
+ * @param {Object} params = Parameters for creating the message.
+ * @param {string} [params.content] - The message content.
+ * @param {string} [params.title] - The title of the embed.
+ * @param {string} [params.url] - The URL of the embed.
+ * @param {Object} [params.author] - The author of the embed.
+ * @param {string} [params.thumbnail] - The thumbnail URL of the embed.
+ * @param {string} [params.description] - The description of the embed.
+ * @param {string} [params.color] - The color of the embed.
+ * @param {Object[]} [params.fields] - The fields of the embed.
+ * @param {string} [params.image] - The image URL of the embed.
+ * @param {string} [params.video] - The video URL of the embed.
+ * @param {Object} [params.footer] - The footer of the embed.
+ * @param {string} [params.timestamp] - The timestamp of the embed.
+ * @param {boolean} [params.ephemeral] - Whether the message should be ephemeral.
+ * @param {boolean} [params.fetchReply] - Whether to fetch the message reply.
+ * @param {Object[] | Object} [params.components] - The message components.
+ * @param {Object[] | Object[]} [params.files] - The message files.
+ * @param {string} [params.reference] - The message reference.
+ * @returns {Object} - The message object.
+ */
+export function CreateMessage({ content, title, url, author, thumbnail, description, color, fields, image, video, footer, timestamp, ephemeral, fetchReply, components, files, reference, }: {
+    content?: string | undefined;
+    title?: string | undefined;
+    url?: string | undefined;
+    author?: Object | undefined;
+    thumbnail?: string | undefined;
+    description?: string | undefined;
+    color?: string | undefined;
+    fields?: Object[] | undefined;
+    image?: string | undefined;
+    video?: string | undefined;
+    footer?: Object | undefined;
+    timestamp?: string | undefined;
+    ephemeral?: boolean | undefined;
+    fetchReply?: boolean | undefined;
+    components?: Object | Object[] | undefined;
+    files?: Object[] | undefined;
+    reference?: string | undefined;
+}): Object;
+export function CreateModal({ title, customId, components }: {
+    title: any;
+    customId: any;
+    components: any;
+}): import("discord.js").APIModalInteractionResponseCallbackData;
+export function SimplifyComponents(data: any): any;
+/**
+ *
+ * @param {*} embed
+ * @returns {boolean}
+ */
+export function isEmptyEmbed(embed: any): boolean;

package/lib/discordjs/mod.js

@@ -0,0 +1,116 @@
+import { EmbedBuilder, ModalBuilder, resolveColor, ActionRow, } from "discord.js";
+import { ComponentType } from "discord-api-types/v10";
+/**
+ *
+ * @param {*} embed
+ * @returns {boolean}
+ */
+function isEmptyEmbed(embed) {
+    const DEFAULT_PROPERTIES = {
+        title: undefined,
+        author: undefined,
+        thumbnail: undefined,
+        description: undefined,
+        fields: undefined,
+        image: undefined,
+        footer: undefined,
+        timestamp: undefined,
+        video: undefined,
+    };
+    // in isEmptyEmbed context is a good compare
+    const isEqualDefault = (key) => String(embed[key]) === String(DEFAULT_PROPERTIES[key]);
+    const isEveryPropertyDefault = Object.keys(DEFAULT_PROPERTIES).every(isEqualDefault);
+    return isEveryPropertyDefault;
+}
+/**
+ * Create a message object for Discord.
+ *
+ * @param {Object} params = Parameters for creating the message.
+ * @param {string} [params.content] - The message content.
+ * @param {string} [params.title] - The title of the embed.
+ * @param {string} [params.url] - The URL of the embed.
+ * @param {Object} [params.author] - The author of the embed.
+ * @param {string} [params.thumbnail] - The thumbnail URL of the embed.
+ * @param {string} [params.description] - The description of the embed.
+ * @param {string} [params.color] - The color of the embed.
+ * @param {Object[]} [params.fields] - The fields of the embed.
+ * @param {string} [params.image] - The image URL of the embed.
+ * @param {string} [params.video] - The video URL of the embed.
+ * @param {Object} [params.footer] - The footer of the embed.
+ * @param {string} [params.timestamp] - The timestamp of the embed.
+ * @param {boolean} [params.ephemeral] - Whether the message should be ephemeral.
+ * @param {boolean} [params.fetchReply] - Whether to fetch the message reply.
+ * @param {Object[] | Object} [params.components] - The message components.
+ * @param {Object[] | Object[]} [params.files] - The message files.
+ * @param {string} [params.reference] - The message reference.
+ * @returns {Object} - The message object.
+ */
+function CreateMessage({ content, title, url, author, thumbnail, description, color, fields, image, video, footer, timestamp, ephemeral, fetchReply, components, files, reference, }) {
+    const message = {};
+    thumbnail && (thumbnail = { url: thumbnail });
+    image && (image = { url: image });
+    video && (video = { url: video });
+    color = resolveColor(color !== null && color !== void 0 ? color : "Random");
+    const embed = new EmbedBuilder({
+        title,
+        url,
+        author,
+        thumbnail,
+        description,
+        color,
+        fields,
+        image,
+        video,
+        footer,
+        timestamp,
+    });
+    if (!isEmptyEmbed(embed.data)) {
+        message.embeds = [embed];
+    }
+    if (files) {
+        message.files = files;
+    }
+    if (reference)
+        message.reply = {
+            messageReference: reference,
+        };
+    message.components = components ? SimplifyComponents(components) : null;
+    message.content = content;
+    message.ephemeral = ephemeral;
+    message.fetchReply = fetchReply;
+    return message;
+}
+function CreateModal({ title, customId, components }) {
+    components = SimplifyComponents(components);
+    return new ModalBuilder({ title, customId, components }).toJSON();
+}
+function SimplifyComponents(data) {
+    if (data instanceof Array && data.length === 0)
+        return [];
+    const isComponent = (component) => "type" in component && component.type !== ComponentType.ActionRow;
+    const isActionRow = (component) => (component instanceof Array && isComponent(component.at(0))) ||
+        component instanceof ActionRow;
+    const isComponents = (component) => component instanceof Array && isActionRow(component.at(0));
+    const argumentType = [
+        isComponent(data),
+        isActionRow(data),
+        isComponents(data),
+    ].findIndex(Boolean);
+    if (argumentType === -1)
+        throw new TypeError("expected component");
+    const wrapToArray = (component) => [component];
+    const arrayToActionRow = (componentsArray) => {
+        const isActionRow = "type" in componentsArray &&
+            componentsArray.type === ComponentType.ActionRow;
+        if (isActionRow)
+            return componentsArray;
+        return { type: ComponentType.ActionRow, components: componentsArray };
+    };
+    if (argumentType <= 0)
+        data = wrapToArray(data);
+    if (argumentType <= 1)
+        data = wrapToArray(data);
+    data = data.map(arrayToActionRow);
+    return data;
+}
+export { CreateMessage, CreateModal, SimplifyComponents, isEmptyEmbed };

package/lib/nodejs/getChildProcessUtils.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import type { ChildProcessWithoutNullStreams } from "child_process";
 import EventsEmitter from "events";
 interface IContext {

package/lib/objectives/DotNotatedInterface.d.ts

@@ -0,0 +1,23 @@
+interface IMethodsOptions {
+    defaultValue?: any;
+    allowSetFunctions?: boolean;
+}
+export declare class DotNotatedInterface {
+    target: Record<string, unknown>;
+    constructor(target: DotNotatedInterface["target"]);
+    getItem<T>(key: string, options?: IMethodsOptions): T | null;
+    setItem<T>(key: string, value: CallableFunction, options?: IMethodsOptions): T;
+    hasItem(key: string, options?: IMethodsOptions): boolean;
+    removeItem(key: string, options?: IMethodsOptions): boolean;
+    getParentAndlastSegmentByNotatedKey(key: string, { needFillIfParentNotExists }: {
+        needFillIfParentNotExists?: boolean | undefined;
+    }): {
+        parent: object | null;
+        lastSegment: string;
+    };
+    fillIsNotExists({ parent, segment, }: {
+        parent: {};
+        segment: string;
+    }): string;
+}
+export {};

package/lib/objectives/DotNotatedInterface.js

@@ -0,0 +1,60 @@
+export class DotNotatedInterface {
+    constructor(target) {
+        this.target = target;
+    }
+    getItem(key, options = {}) {
+        var _a;
+        const { parent, lastSegment } = this.getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists: false });
+        if (!parent || lastSegment in parent === false) {
+            return (_a = options.defaultValue) !== null && _a !== void 0 ? _a : null;
+        }
+        // @ts-ignore
+        return parent[lastSegment];
+    }
+    setItem(key, value, options = {}) {
+        if (typeof value === "function" && !options.allowSetFunctions) {
+            value = value(this.getItem(key, options));
+        }
+        const { parent, lastSegment } = this.getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists: true });
+        // @ts-ignore
+        return (parent[lastSegment] = value);
+    }
+    hasItem(key, options = {}) {
+        const { parent, lastSegment } = this.getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists: false });
+        if (parent === null) {
+            return false;
+        }
+        return lastSegment in parent;
+    }
+    removeItem(key, options = {}) {
+        const { parent, lastSegment } = this.getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists: false });
+        if (!parent) {
+            return false;
+        }
+        // @ts-ignore
+        return delete parent[lastSegment];
+    }
+    getParentAndlastSegmentByNotatedKey(key, { needFillIfParentNotExists = false }) {
+        const pathSegments = key.split(".");
+        if (!pathSegments.length) {
+            throw new Error("Empty path to property");
+        }
+        let parent = this.target;
+        for (let segment of pathSegments.slice(0, -1)) {
+            needFillIfParentNotExists &&
+                (segment = this.fillIsNotExists({ parent, segment }));
+            if (parent[segment] === undefined) {
+                return { parent: null, lastSegment: segment };
+            }
+            parent = parent[segment];
+        }
+        return { parent, lastSegment: pathSegments.at(-1) };
+    }
+    fillIsNotExists({ parent, segment, }) {
+        if (segment in parent === false) {
+            // @ts-ignore
+            parent[segment] = {};
+        }
+        return segment;
+    }
+}

package/lib/objectives/GlitchText.js

@@ -1,4 +1,4 @@
-import { getRandomValue } from "./getRandomValue.js";
+import { getRandomNumberInRange } from "./getRandomNumberInRange.js";
 class GlitchText {
     constructor(from = "", to = "hello, world", { step = 15, random = false, maximum = 100 } = {}) {
         this.from = from;
@@ -18,7 +18,7 @@ class GlitchText {
                 word.pop();
             if (word.length < target.length)
                 word.push(String.fromCharCode(~~(Math.random() * 50)));
-            word.forEach((_, index, array) => array[index] = String.fromCharCode(getRandomValue({ min: MIN, max: MAX })));
+            word.forEach((_, index, array) => array[index] = String.fromCharCode(getRandomNumberInRange({ min: MIN, max: MAX })));
             yield word.join("");
         }
         if (this.maximum)

package/lib/objectives/getRandomElementFromArray.d.ts

@@ -0,0 +1,7 @@
+interface IParams {
+    needPop?: boolean;
+    associatedWeights?: number[];
+}
+export declare function getRandomElementIndexInWeights(weights: NonNullable<IParams["associatedWeights"]>): number | never;
+export declare function getRandomElementFromArray<T>(array: T[], { needPop, associatedWeights }?: IParams): T;
+export {};

package/lib/objectives/getRandomElementFromArray.js

@@ -0,0 +1,24 @@
+import { getRandomNumberInRange } from "./getRandomNumberInRange.js";
+export function getRandomElementIndexInWeights(weights) {
+    if (weights.length < 1) {
+        new Error("Invalid array length");
+    }
+    let previousLimit = 0;
+    const thresholds = weights.map((weight) => (previousLimit += weight));
+    const lotterySecretNumber = Math.random() * thresholds.at(-1);
+    return thresholds.findIndex((threshold) => threshold >= lotterySecretNumber);
+}
+export function getRandomElementFromArray(array, { needPop, associatedWeights } = {}) {
+    if (associatedWeights && associatedWeights.length !== array.length) {
+        throw new Error("Incorrectly passed argument associatedWeights: The length of the associatedWeights must exactly match the length of the weights array");
+    }
+    const index = associatedWeights
+        ? getRandomElementIndexInWeights(associatedWeights)
+        : getRandomNumberInRange({ max: array.length });
+    const input = array[index];
+    if (needPop) {
+        array.splice(index, 1);
+        associatedWeights === null || associatedWeights === void 0 ? void 0 : associatedWeights.splice(index, 1);
+    }
+    return input;
+}

package/lib/objectives/getRandomNumberInRange.d.ts

@@ -0,0 +1,7 @@
+interface IGetRandomValueOptions {
+    min?: number;
+    max: number;
+    needRound?: boolean;
+}
+declare function getRandomNumberInRange({ min, max, needRound }: IGetRandomValueOptions): number;
+export { getRandomNumberInRange };

package/lib/objectives/getRandomNumberInRange.js

@@ -0,0 +1,8 @@
+function getRandomNumberInRange({ min = 0, max, needRound = true }) {
+    let value = Math.random() * (max - min + Number(needRound)) + min;
+    if (needRound) {
+        value = Math.floor(value);
+    }
+    return value;
+}
+export { getRandomNumberInRange };

package/lib/objectives/mod.d.ts

@@ -1,8 +1,8 @@
 export * from './CustomCollector.js';
 export * from './GlitchText.js';
-export * from './getRandomValue.js';
+export * from './getRandomNumberInRange.js';
 export * from './rangeToArray.js';
-declare function omit(object: object, filter: CallableFunction): {
+declare function omit(object: Object, filter: CallableFunction): {
     [k: string]: any;
 };
 export { omit };

package/lib/objectives/mod.js

@@ -1,6 +1,6 @@
 export * from './CustomCollector.js';
 export * from './GlitchText.js';
-export * from './getRandomValue.js';
+export * from './getRandomNumberInRange.js';
 export * from './rangeToArray.js';
 function omit(object, filter) {
     const entries = Object.entries(object)

package/lib/primitives/TextTableBuilder.d.ts

@@ -0,0 +1,66 @@
+interface ITextTableGeneratorContext {
+    content: string;
+    metadata: IContextMetadata;
+    currentRow: number;
+}
+interface IContextMetadata {
+    columns?: {
+        largestLength: number;
+    }[];
+    tableWidth?: number;
+    separatorsIndexesInRow?: number[];
+}
+declare enum CellAlignEnum {
+    Left = 0,
+    Right = 1,
+    Center = 2
+}
+interface ICellOptions {
+    gapLeft: number;
+    gapRight: number;
+    align: CellAlignEnum;
+    removeNextSeparator?: boolean;
+}
+interface ITableCell {
+    value: string;
+    options: ICellOptions;
+}
+type TCellSetSymbolCallback = (context: ITextTableGeneratorContext, index: number) => string;
+interface ITableOptions {
+    borderLeft: null | TCellSetSymbolCallback;
+    borderRight: null | TCellSetSymbolCallback;
+    borderTop: null | TCellSetSymbolCallback;
+    borderBottom: null | TCellSetSymbolCallback;
+    separator: string;
+}
+declare enum BorderDirectionEnum {
+    BorderLeft = 0,
+    BorderRight = 1,
+    BorderTop = 2,
+    BorderBottom = 3
+}
+declare enum SpecialRowTypeEnum {
+    Default = 0,
+    Display = 1
+}
+interface ITableSpecialDisplayRow {
+    type: SpecialRowTypeEnum.Display;
+    display: TCellSetSymbolCallback;
+}
+type TTableRow = ITableCell[] | ITableSpecialDisplayRow;
+declare class TextTableBuilder {
+    rows: TTableRow[];
+    protected options: ITableOptions;
+    setBorderOptions(callback?: TCellSetSymbolCallback, directions?: BorderDirectionEnum[]): this;
+    addRowWithElements(elements: ITableCell["value"][], optionsForEveryElement?: Partial<ICellOptions>): this;
+    addMultilineRowWithElements(elements: ITableCell["value"][], optionsForEveryElement?: Partial<ICellOptions>): this;
+    addEmptyRow(): this;
+    addRowSeparator(setSymbol?: TCellSetSymbolCallback): this;
+    addCellAtRow(rowIndex: number, cellValue: ITableCell["value"], cellOptions: ICellOptions): this;
+    pushCellToArray<T = ITableCell>(array: (T | ITableCell)[], cellValue: ITableCell["value"], cellOptions?: Partial<ICellOptions>): this;
+    pushRowToTable(row: TTableRow): this;
+    generateTextContent(): string;
+}
+export { TextTableBuilder };
+export { SpecialRowTypeEnum, CellAlignEnum, BorderDirectionEnum };
+export type { ICellOptions, IContextMetadata, ITableCell, ITableOptions, ITextTableGeneratorContext, TTableRow, };

package/lib/primitives/TextTableBuilder.js

@@ -0,0 +1,269 @@
+function getRowType(row) {
+    if ("type" in row === false) {
+        return SpecialRowTypeEnum.Default;
+    }
+    return row.type;
+}
+function isCell(target) {
+    return "value" in target && "options" in target;
+}
+class TextTableGenerator {
+    constructor(rows, options) {
+        this.data = [];
+        this.context = {
+            content: "",
+            metadata: {},
+            currentRow: 0,
+        };
+        this.data = rows;
+        this.options = options;
+        this.parseMetadata();
+    }
+    generateTextContent() {
+        const context = this.context;
+        if (this.options.borderTop !== null) {
+            context.content += this.drawBlockBorder(BorderDirectionEnum.BorderTop);
+            context.content += "\n";
+        }
+        for (const row of this.data) {
+            context.currentRow = this.data.indexOf(row);
+            context.content += this.drawRow(row);
+            context.content += "\n";
+        }
+        if (this.options.borderBottom !== null) {
+            context.content += this.drawBlockBorder(BorderDirectionEnum.BorderBottom);
+        }
+        return context.content;
+    }
+    getColumns() {
+        const columns = [];
+        const rows = this.data;
+        const largestCellsCount = Math.max(...rows
+            .filter((row) => getRowType(row) === SpecialRowTypeEnum.Default)
+            .map((row) => row.length));
+        for (let index = 0; index < largestCellsCount; index++) {
+            const column = rows.map((row) => getRowType(row) === SpecialRowTypeEnum.Default
+                ? row.at(index)
+                : { row });
+            columns.push(column);
+        }
+        return columns;
+    }
+    parseMetadata() {
+        const metadata = this.context.metadata;
+        const columns = this.getColumns();
+        const columnsMetadata = columns.map((column) => ({
+            largestLength: Math.max(...column.map((element) => isCell(element)
+                ? this.calculateCellMinWidth(element)
+                : 0)),
+        }));
+        metadata.columns = columnsMetadata;
+        metadata.tableWidth = this.calculateTableWidth();
+        metadata.separatorsIndexesInRow = (() => {
+            const indexes = [];
+            let current = 0;
+            if (!!this.options.borderLeft) {
+                indexes.push(current);
+            }
+            for (const { largestLength } of columnsMetadata) {
+                current += largestLength + 1;
+                indexes.push(current);
+            }
+            if (!this.options.borderRight) {
+                indexes.pop();
+            }
+            return indexes;
+        })();
+    }
+    drawRow(row) {
+        var _a, _b, _c, _d, _e, _f;
+        let content = "";
+        const context = this.context;
+        const metadata = context.metadata;
+        if (getRowType(row) === SpecialRowTypeEnum.Default) {
+            row = row;
+            content += (_c = (_b = (_a = this.options).borderLeft) === null || _b === void 0 ? void 0 : _b.call(_a, context, context.currentRow)) !== null && _c !== void 0 ? _c : "";
+            for (const cellIndex in row) {
+                const cell = row.at(+cellIndex);
+                const expectedWidth = metadata.columns.at(+cellIndex).largestLength;
+                content += this.drawCell(cell, expectedWidth);
+                if (+cellIndex !== row.length - 1) {
+                    content += !cell.options.removeNextSeparator
+                        ? this.options.separator
+                        : " ";
+                }
+            }
+            content += (_f = (_e = (_d = this.options).borderRight) === null || _e === void 0 ? void 0 : _e.call(_d, context, context.currentRow)) !== null && _f !== void 0 ? _f : "";
+            return content;
+        }
+        if (getRowType(row) === SpecialRowTypeEnum.Display) {
+            row = row;
+            content += this.drawLine(row.display);
+        }
+        return content;
+    }
+    drawCell(cell, expectedWidth) {
+        const { gapLeft, gapRight, align } = cell.options;
+        const { value } = cell;
+        const minContentLength = this.calculateCellMinWidth(cell);
+        const addidableGapLeft = align === CellAlignEnum.Right
+            ? expectedWidth - minContentLength
+            : align === CellAlignEnum.Center
+                ? Math.floor((expectedWidth - minContentLength) / 2)
+                : 0;
+        const addidableGapRight = align === CellAlignEnum.Left
+            ? expectedWidth - minContentLength
+            : align === CellAlignEnum.Center
+                ? Math.ceil((expectedWidth - minContentLength) / 2)
+                : 0;
+        return `${" ".repeat(gapLeft + addidableGapLeft)}${value}${" ".repeat(gapRight + addidableGapRight)}`;
+    }
+    drawLine(setSymbol) {
+        let content = "";
+        const context = this.context;
+        const length = this.calculateTableWidth();
+        for (const index in [...new Array(length)]) {
+            const symbol = setSymbol(context, +index);
+            content += symbol;
+        }
+        return content;
+    }
+    drawBlockBorder(borderDirection) {
+        const callback = borderDirection === BorderDirectionEnum.BorderTop
+            ? this.options.borderTop
+            : this.options.borderBottom;
+        return this.drawLine(callback);
+    }
+    calculateTableWidth() {
+        const { columns } = this.context.metadata;
+        if (!columns) {
+            throw new Error("No columns field; Tip: Use <this>.parseMetadata() previous");
+        }
+        const cells = columns.reduce((acc, current) => current.largestLength + acc, 0);
+        const separators = columns.length - 1;
+        const borders = +!!this.options.borderLeft + +!!this.options.borderRight;
+        return cells + separators + borders;
+    }
+    calculateCellMinWidth(cell) {
+        return cell.value.length + cell.options.gapLeft + cell.options.gapRight;
+    }
+}
+var CellAlignEnum;
+(function (CellAlignEnum) {
+    CellAlignEnum[CellAlignEnum["Left"] = 0] = "Left";
+    CellAlignEnum[CellAlignEnum["Right"] = 1] = "Right";
+    CellAlignEnum[CellAlignEnum["Center"] = 2] = "Center";
+})(CellAlignEnum || (CellAlignEnum = {}));
+const DEFAULT_CELL_OPTIONS = {
+    gapLeft: 2,
+    gapRight: 2,
+    align: CellAlignEnum.Left,
+};
+var BorderDirectionEnum;
+(function (BorderDirectionEnum) {
+    BorderDirectionEnum[BorderDirectionEnum["BorderLeft"] = 0] = "BorderLeft";
+    BorderDirectionEnum[BorderDirectionEnum["BorderRight"] = 1] = "BorderRight";
+    BorderDirectionEnum[BorderDirectionEnum["BorderTop"] = 2] = "BorderTop";
+    BorderDirectionEnum[BorderDirectionEnum["BorderBottom"] = 3] = "BorderBottom";
+})(BorderDirectionEnum || (BorderDirectionEnum = {}));
+const DEFAULT_TABLE_OPTIONS = {
+    borderLeft: null,
+    borderRight: null,
+    borderTop: null,
+    borderBottom: null,
+    separator: "|",
+};
+var SpecialRowTypeEnum;
+(function (SpecialRowTypeEnum) {
+    SpecialRowTypeEnum[SpecialRowTypeEnum["Default"] = 0] = "Default";
+    SpecialRowTypeEnum[SpecialRowTypeEnum["Display"] = 1] = "Display";
+})(SpecialRowTypeEnum || (SpecialRowTypeEnum = {}));
+class TextTableBuilder {
+    constructor() {
+        this.rows = [];
+        this.options = DEFAULT_TABLE_OPTIONS;
+    }
+    setBorderOptions(callback = () => "|", directions = [
+        BorderDirectionEnum.BorderLeft,
+        BorderDirectionEnum.BorderRight,
+    ]) {
+        for (const direction of directions) {
+            switch (direction) {
+                case BorderDirectionEnum.BorderLeft:
+                    this.options.borderLeft = callback;
+                    break;
+                case BorderDirectionEnum.BorderRight:
+                    this.options.borderRight = callback;
+                    break;
+                case BorderDirectionEnum.BorderTop:
+                    this.options.borderTop = callback;
+                    break;
+                case BorderDirectionEnum.BorderBottom:
+                    this.options.borderBottom = callback;
+                    break;
+            }
+        }
+        return this;
+    }
+    addRowWithElements(elements, optionsForEveryElement) {
+        const row = [];
+        for (const value of elements) {
+            this.pushCellToArray(row, value, optionsForEveryElement);
+        }
+        this.pushRowToTable(row);
+        return this;
+    }
+    addMultilineRowWithElements(elements, optionsForEveryElement) {
+        const separatedElements = elements.map((value) => value.split("\n"));
+        const largestHeight = Math.max(...separatedElements.map((sub) => sub.length));
+        for (let index = 0; index < largestHeight; index++) {
+            this.addRowWithElements(separatedElements.map((sub) => { var _a; return (_a = sub.at(index)) !== null && _a !== void 0 ? _a : ""; }), optionsForEveryElement);
+        }
+        return this;
+    }
+    addEmptyRow() {
+        this.pushRowToTable([]);
+        return this;
+    }
+    addRowSeparator(setSymbol = () => "-") {
+        const row = {
+            display: setSymbol,
+            type: SpecialRowTypeEnum.Display,
+        };
+        this.pushRowToTable(row);
+        return this;
+    }
+    addCellAtRow(rowIndex, cellValue, cellOptions) {
+        const row = this.rows.at(rowIndex);
+        if (!row) {
+            throw new RangeError("");
+        }
+        if (getRowType(row) !== SpecialRowTypeEnum.Default) {
+            throw new Error("Is not default row: without cells");
+        }
+        this.pushCellToArray(row, cellValue, cellOptions);
+        return this;
+    }
+    pushCellToArray(array, cellValue, cellOptions = {}) {
+        const options = Object.assign({}, DEFAULT_CELL_OPTIONS, cellOptions);
+        array.push({ value: cellValue, options });
+        return this;
+    }
+    pushRowToTable(row) {
+        this.rows.push(row);
+        return this;
+    }
+    generateTextContent() {
+        return new TextTableGenerator(this.rows, this.options).generateTextContent();
+    }
+}
+export { TextTableBuilder };
+export { SpecialRowTypeEnum, CellAlignEnum, BorderDirectionEnum };
+const builder = new TextTableBuilder()
+    .setBorderOptions()
+    .addRowWithElements(["1", "212", "3"], { align: CellAlignEnum.Left })
+    .addRowWithElements(["1", "2", "3"], { align: CellAlignEnum.Right })
+    .addRowSeparator()
+    .addRowWithElements(["777", "555", "1999"], { align: CellAlignEnum.Center });
+// the example has been simplified
+console.log(builder.generateTextContent());

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@zoodogood/utils",
   "type": "module",
-  "version": "1.0.4",
+  "version": "1.0.6-change.694",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "homepage": "https://zoodogood.github.io/utils",
   "scripts": {
-    "test": "node index",
+    "test": "vitest",
     "docs-build": "cd ./docs && retype build  --output ./public",
     "docs-watch": "cd ./docs && retype watch",
-    "prepack": "tsc"
+    "prepack": "tsc",
+    "build": "tsc"
   },
   "typings": "lib/index",
   "exports": {
@@ -31,7 +32,8 @@
     "@types/node": "^20.5.9",
     "discord.js": "^14.13.0",
     "retypeapp-linux-x64": "^3.3.0",
-    "typescript": "^5.2.2"
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.5"
   },
   "peerDependencies": {
     "discord.js": "=>14.x.x"

package/readme.md

@@ -7,4 +7,7 @@ https://zoodogood.github.io/utils/public
 export { ending } from '@zoodogood/utils/primitives';
 ```
 
-[NPM](https://www.npmjs.com/package/@zoodogood/utils)
+[NPM](https://www.npmjs.com/package/@zoodogood/utils)
+
+#### From developer:
+(Wa) Use only documented functions that are not marked "Unstable". Thanks.