@zoodogood/utils 1.1.3-change.1055 → 1.2.0-change.1444

package/lib/objectives/ExtendedEnum/mod.d.ts

@@ -1,2 +1,4 @@
 export * from "./Result.js";
+export * from "./Option.js";
+export * from "./BooleanWithMessage.js";
 export * from "./main.js";

package/lib/objectives/ExtendedEnum/mod.js

@@ -1,2 +1,4 @@
 export * from "./Result.js";
+export * from "./Option.js";
+export * from "./BooleanWithMessage.js";
 export * from "./main.js";

package/lib/primitives/BracketsParser.d.ts

@@ -0,0 +1,75 @@
+type TCompareSequence = string | RegExp;
+interface IBracketVariant {
+    key: string;
+    start: TCompareSequence;
+    end: TCompareSequence;
+    isRegex?: boolean;
+    isSequence?: boolean;
+}
+declare class StackElement {
+    indexInText?: number;
+    isRegex: boolean;
+    match: null;
+    key?: string;
+    full?: string;
+    variant?: IBracketVariant;
+    get length(): number | undefined;
+    static from(data: unknown): StackElement;
+}
+declare class GroupElement {
+    start?: StackElement;
+    end?: StackElement;
+    content?: string;
+    subgroups: GroupElement[];
+    depth: number;
+    get key(): string | undefined;
+    get indexInText(): number | undefined;
+    get length(): number;
+    get full(): string | null;
+    isParentFor(group: GroupElement): boolean;
+    static from(data: unknown): GroupElement;
+}
+declare class ParseContext {
+    stack: StackElement[];
+    indexInText: number;
+    text?: string;
+    groups: Array<GroupElement>;
+    setText(text: string): void;
+    appendGroup(group: GroupElement): void;
+}
+export declare class BracketsParser {
+    variants: Map<string, IBracketVariant>;
+    addBracketVariant(...variants: IBracketVariant[]): this;
+    setBracketVariant(...variants: IBracketVariant[]): this;
+    processSymbol(symbol: string, context: ParseContext): void;
+    processBracket(symbol: string, context: ParseContext): void;
+    processBracketClose(symbol: string, context: ParseContext): StackElement | undefined;
+    _createGroup(start: StackElement, end: StackElement, context: ParseContext): GroupElement;
+    processBracketOpen(symbol: string, context: ParseContext): StackElement | null;
+    /**
+     * @note Regular sequences of expressions must starts with ^
+     */
+    sequenceCaptureProtocol(compare: TCompareSequence, context: ParseContext): {
+        match: true | RegExpMatchArray;
+        isRegex: boolean;
+        full: string;
+        indexInText: number;
+    } | null;
+    symbolCaptureProtocol(symbol: string, compare: TCompareSequence, context: ParseContext): {
+        match: true | RegExpMatchArray;
+        isRegex: boolean;
+        full: string;
+        indexInText: number;
+    } | null;
+    processSlash(symbol: string, context: ParseContext): void;
+    parse(text: string): ParseContext;
+    static ParseContext: typeof ParseContext;
+    static GroupElement: typeof GroupElement;
+    static StackElement: typeof StackElement;
+    static get defaultBracketVariants(): {
+        key: string;
+        start: string;
+        end: string;
+    }[];
+}
+export {};

package/lib/primitives/BracketsParser.js

@@ -0,0 +1,206 @@
+class StackElement {
+    constructor() {
+        this.isRegex = false;
+        this.match = null;
+    }
+    get length() {
+        var _a;
+        return (_a = this.full) === null || _a === void 0 ? void 0 : _a.length;
+    }
+    static from(data) {
+        return Object.assign(new this(), data);
+    }
+}
+class GroupElement {
+    constructor() {
+        this.subgroups = [];
+        this.depth = 0;
+    }
+    get key() {
+        var _a;
+        return (_a = this.start) === null || _a === void 0 ? void 0 : _a.key;
+    }
+    get indexInText() {
+        var _a;
+        return (_a = this.start) === null || _a === void 0 ? void 0 : _a.indexInText;
+    }
+    get length() {
+        var _a, _b, _c, _d;
+        return (
+        // @ts-expect-error May be undefined
+        ((_a = this.end) === null || _a === void 0 ? void 0 : _a.indexInText) - ((_b = this.start) === null || _b === void 0 ? void 0 : _b.indexInText) + ((_d = (_c = this.end) === null || _c === void 0 ? void 0 : _c.full) === null || _d === void 0 ? void 0 : _d.length));
+    }
+    get full() {
+        var _a, _b;
+        // @ts-expect-error May be undefined
+        return ((_a = this.start) === null || _a === void 0 ? void 0 : _a.full) + this.content + ((_b = this.end) === null || _b === void 0 ? void 0 : _b.full) || null;
+    }
+    isParentFor(group) {
+        const { start: targetStart, end: targetEnd } = group;
+        return (
+        // @ts-expect-error Maybe null
+        this.start.indexInText < targetStart.indexInText &&
+            // @ts-expect-error Maybe null
+            this.end.indexInText > targetEnd.indexInText);
+    }
+    static from(data) {
+        return Object.assign(new this(), data);
+    }
+}
+class ParseContext {
+    constructor() {
+        this.stack = [];
+        this.indexInText = 0;
+        this.groups = [];
+    }
+    setText(text) {
+        this.text = text;
+    }
+    appendGroup(group) {
+        this.groups.push(group);
+    }
+}
+export class BracketsParser {
+    constructor() {
+        this.variants = new Map();
+    }
+    addBracketVariant(...variants) {
+        for (const variant of variants) {
+            const { key } = variant;
+            this.variants.set(key, variant);
+        }
+        return this;
+    }
+    setBracketVariant(...variants) {
+        [...this.variants.keys()].forEach((key) => this.variants.delete(key));
+        this.addBracketVariant(...variants);
+        return this;
+    }
+    processSymbol(symbol, context) {
+        this.processSlash(symbol, context);
+        this.processBracket(symbol, context);
+    }
+    processBracket(symbol, context) {
+        this.processBracketClose(symbol, context) ||
+            this.processBracketOpen(symbol, context);
+    }
+    processBracketClose(symbol, context) {
+        if (!context.stack.length) {
+            return;
+        }
+        const { key } = context.stack.at(-1);
+        const variant = this.variants.get(key);
+        const match = variant.isSequence
+            ? this.sequenceCaptureProtocol(variant.end, context)
+            : this.symbolCaptureProtocol(symbol, variant.end, context);
+        if (!match) {
+            return;
+        }
+        const start = context.stack.pop();
+        const end = StackElement.from(Object.assign(Object.assign({}, match), { key: variant.key, variant }));
+        const group = this._createGroup(start, end, context);
+        context.appendGroup(group);
+        return end;
+    }
+    _createGroup(start, end, context) {
+        const content = context.text.slice(start.indexInText + start.length, end.indexInText);
+        const group = GroupElement.from({ start, end, content });
+        const potentialChild = context.groups.at(-1);
+        if (potentialChild && group.isParentFor(potentialChild)) {
+            group.subgroups.push(potentialChild);
+        }
+        group.depth = context.stack.length;
+        return group;
+    }
+    processBracketOpen(symbol, context) {
+        const result = (() => {
+            for (const variant of this.variants.values()) {
+                const match = variant.isSequence
+                    ? this.sequenceCaptureProtocol(variant.start, context)
+                    : this.symbolCaptureProtocol(symbol, variant.start, context);
+                if (match) {
+                    return { match, variant };
+                }
+            }
+        })();
+        if (!result) {
+            return null;
+        }
+        const { match, variant } = result;
+        const start = StackElement.from(Object.assign(Object.assign({}, match), { key: variant.key, variant }));
+        context.stack.push(start);
+        return start;
+    }
+    /**
+     * @note Regular sequences of expressions must starts with ^
+     */
+    sequenceCaptureProtocol(compare, context) {
+        const indexInText = context.indexInText;
+        const target = context.text.slice(indexInText);
+        const isRegex = compare instanceof RegExp;
+        const match = isRegex ? target.match(compare) : target.startsWith(compare);
+        if (!match) {
+            return null;
+        }
+        const full = (isRegex ? match[0] : compare);
+        context.indexInText += full.length - 1;
+        return { match, isRegex, full, indexInText };
+    }
+    symbolCaptureProtocol(symbol, compare, context) {
+        const indexInText = context.indexInText;
+        const isRegex = compare instanceof RegExp;
+        const match = isRegex ? symbol.match(compare) : symbol === compare;
+        if (!match) {
+            return null;
+        }
+        const full = symbol;
+        return { match, isRegex, full, indexInText };
+    }
+    processSlash(symbol, context) {
+        if (symbol !== "\\") {
+            return;
+        }
+        context.indexInText++;
+    }
+    parse(text) {
+        const context = new ParseContext();
+        context.setText(text);
+        while (true) {
+            const index = context.indexInText;
+            const symbol = text[index] || "";
+            this.processSymbol(symbol, context);
+            if (symbol === "") {
+                break;
+            }
+            context.indexInText++;
+        }
+        return context;
+    }
+    static get defaultBracketVariants() {
+        return [
+            {
+                key: "{}",
+                start: "{",
+                end: "}",
+            },
+            {
+                key: "[]",
+                start: "[",
+                end: "]",
+            },
+            {
+                key: "()",
+                start: "(",
+                end: ")",
+            },
+            {
+                key: '""',
+                start: '"',
+                end: '"',
+            },
+        ];
+    }
+}
+BracketsParser.ParseContext = ParseContext;
+BracketsParser.GroupElement = GroupElement;
+BracketsParser.StackElement = StackElement;

package/lib/primitives/CliParser.d.ts

@@ -0,0 +1,89 @@
+import { BracketsParser } from "./BracketsParser.js";
+interface ITextMatch {
+    regex: RegExp;
+    name: string;
+}
+declare namespace BracketsNamespace {
+    type Context = InstanceType<typeof BracketsParser.ParseContext>;
+    type GroupElement = InstanceType<typeof BracketsManager.GroupElement>;
+}
+declare class BracketsManager extends BracketsParser {
+    primary: BracketsNamespace.GroupElement[];
+    constructor();
+    parse(): BracketsNamespace.Context;
+    parseSafe(text: string): {
+        context: BracketsNamespace.Context;
+        indexes: number[];
+    };
+    useWriteToPrimaryProtocol(context: BracketsNamespace.Context): {
+        indexes: number[];
+    };
+    toStringGroup(index: number): string;
+    findPrimaryGroups(context: BracketsNamespace.Context): BracketsNamespace.GroupElement[];
+    findBracketStamp(text: string): RegExpMatchArray | null;
+    processBracketGroupFromStringStamp(raw: string): BracketsNamespace.GroupElement | null;
+}
+interface IFlagCapture {
+    name?: string;
+    capture: string[];
+    expectValue?: boolean;
+}
+declare class FlagsManager {
+    unhandledFlags?: Array<RegExpMatchArray>;
+    captureResidueFlags(context: CliParserRunContext): this;
+    captureFlags(flags: IFlagCapture[], context: CliParserRunContext): this;
+}
+type TCaptureValue = string | RegExpMatchArray;
+declare class CapturedContent {
+    content: TCaptureValue;
+    context?: CliParserRunContext;
+    constructor(content: TCaptureValue);
+    setContextInstance(context: CapturedContent["context"]): this;
+    isRegexMatchArray(): boolean;
+    isString(): boolean;
+    isBracketGroupStamp(): boolean | null;
+    toGroupElement(): BracketsNamespace.GroupElement | null;
+    toString(addable?: {
+        trim?: boolean;
+        smart?: boolean;
+    }): string | undefined;
+    regexArrayOrStringToString(): string;
+    static contentIsRegExpMatchArray(content: TCaptureValue): boolean;
+    static contentIsString(content: TCaptureValue): boolean;
+    static contentIsBracketGroupStamp(content: TCaptureValue, context: CliParserRunContext): boolean | null;
+    static contentToGroupElement(content: TCaptureValue, context: CliParserRunContext): BracketsNamespace.GroupElement | null;
+    static regexArrayOrStringToString(content: TCaptureValue): string;
+    static contentToString(content: TCaptureValue, context?: CliParserRunContext, { trim, smart }?: {
+        trim?: boolean | undefined;
+        smart?: boolean | undefined;
+    }): string | undefined;
+}
+declare class CliParserRunContext {
+    parser: CliParser;
+    input: string;
+    captures: Map<string, CapturedContent | null>;
+    brackets: BracketsManager;
+    flags: FlagsManager;
+    constructor(parser: CliParser);
+    resolveValues<T = unknown>(resolver: (captured: CapturedContent | null) => T): Map<string, T>;
+}
+export declare class CliParser {
+    context: CliParserRunContext;
+    constructor();
+    processBrackets(): this;
+    captureFlags(flags: IFlagCapture[]): this;
+    captureResidueFlags(): this;
+    setText(text: string): this;
+    captureResidue({ name }: {
+        name: string;
+    }): this;
+    replaceByMatch(regex: RegExp): RegExpMatchArray | null;
+    captureByMatch({ regex, name }: ITextMatch): this;
+    replaceTextByIndexes(start: number, length: number, replacer: (string: string) => string): void;
+    collect(): CliParserRunContext;
+    static CliParserRunContext: typeof CliParserRunContext;
+    static CapturedContent: typeof CapturedContent;
+    static BracketsManager: typeof BracketsManager;
+    static FlagsManager: typeof FlagsManager;
+}
+export {};

package/lib/primitives/CliParser.js

@@ -0,0 +1,245 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import { BracketsParser } from "./BracketsParser.js";
+class BracketsManager extends BracketsParser {
+    constructor() {
+        super();
+        this.primary = [];
+        this.addBracketVariant(...BracketsParser.defaultBracketVariants);
+    }
+    parse() {
+        throw new Error("Use parseSafe instead");
+    }
+    parseSafe(text) {
+        const context = super.parse(text);
+        const { indexes } = this.useWriteToPrimaryProtocol(context);
+        return { indexes, context };
+    }
+    useWriteToPrimaryProtocol(context) {
+        const primary = this.findPrimaryGroups(context);
+        const indexes = [...new Array(primary.length)].map((_, index) => this.primary.length + index);
+        this.primary.push(...primary);
+        return { indexes };
+    }
+    toStringGroup(index) {
+        return `[Group*${index}]`;
+    }
+    findPrimaryGroups(context) {
+        return context.groups.filter((group) => group.depth === 0);
+    }
+    findBracketStamp(text) {
+        return text.trim().match(/^\[Group\*(?<index>\d+)\]$/);
+    }
+    processBracketGroupFromStringStamp(raw) {
+        const match = this.findBracketStamp(raw);
+        if (!match) {
+            return null;
+        }
+        const { index } = match.groups;
+        return this.primary.at(+index);
+    }
+}
+class FlagsManager {
+    captureResidueFlags(context) {
+        let match;
+        const { parser } = context;
+        while ((match = parser.replaceByMatch(/-{1,2}\w/))) {
+            this.unhandledFlags || (this.unhandledFlags = []);
+            this.unhandledFlags.push(match);
+        }
+        return this;
+    }
+    captureFlags(flags, context) {
+        for (const { name, capture, expectValue } of flags) {
+            for (const flag of capture) {
+                const regex = `(?<=^|\\s)${flag}${expectValue ? "(?:(?:\\s+|=)(?<value>[^\\s]+))" : ""}`;
+                const { parser } = context;
+                const captureName = name || flag;
+                const match = parser.replaceByMatch(RegExp(regex, "i"));
+                if (!match) {
+                    context.captures.set(`${captureName}`, null);
+                    continue;
+                }
+                context.captures.set(`${captureName}`, new CapturedContent(match).setContextInstance(context));
+            }
+        }
+        return this;
+    }
+}
+class CapturedContent {
+    constructor(content) {
+        this.content = content;
+    }
+    setContextInstance(context) {
+        this.context = context;
+        return this;
+    }
+    isRegexMatchArray() {
+        return CapturedContent.contentIsRegExpMatchArray(this.content);
+    }
+    isString() {
+        return CapturedContent.contentIsString(this.content);
+    }
+    isBracketGroupStamp() {
+        const { content, context } = this;
+        if (!context) {
+            throw new Error("context is undefined or null");
+        }
+        return CapturedContent.contentIsBracketGroupStamp(content, context);
+    }
+    toGroupElement() {
+        const { content, context } = this;
+        if (!context) {
+            throw new Error("context is undefined or null");
+        }
+        return CapturedContent.contentToGroupElement(content, context);
+    }
+    toString(addable = {}) {
+        return CapturedContent.contentToString(this.content, this.context, addable);
+    }
+    regexArrayOrStringToString() {
+        return CapturedContent.regexArrayOrStringToString(this.content);
+    }
+    static contentIsRegExpMatchArray(content) {
+        return (content instanceof Array &&
+            Object.prototype.hasOwnProperty.call(content, "index") &&
+            Object.prototype.hasOwnProperty.call(content, "input"));
+    }
+    static contentIsString(content) {
+        return typeof content === "string";
+    }
+    static contentIsBracketGroupStamp(content, context) {
+        const { brackets } = context || {};
+        if (!brackets) {
+            return null;
+        }
+        if (!content) {
+            return false;
+        }
+        content = this.regexArrayOrStringToString(content);
+        return !!brackets.findBracketStamp(content);
+    }
+    static contentToGroupElement(content, context) {
+        content = this.regexArrayOrStringToString(content);
+        const { brackets } = context || {};
+        return brackets.processBracketGroupFromStringStamp(content);
+    }
+    static regexArrayOrStringToString(content) {
+        var _a;
+        if (this.contentIsString(content)) {
+            return content;
+        }
+        return ((_a = content.groups) === null || _a === void 0 ? void 0 : _a.value) || content[0];
+    }
+    static contentToString(content, context, { trim = true, smart = true } = {}) {
+        let value = ((content) => {
+            var _a;
+            if (!smart) {
+                return String(content);
+            }
+            if (this.contentIsRegExpMatchArray(content)) {
+                content = this.regexArrayOrStringToString(content);
+            }
+            if (context && this.contentIsBracketGroupStamp(content, context)) {
+                return ((_a = this.contentToGroupElement(content, context)) === null || _a === void 0 ? void 0 : _a.full) || content;
+            }
+            return content;
+        })(content);
+        if (trim) {
+            value = value === null || value === void 0 ? void 0 : value.trim();
+        }
+        return value;
+    }
+}
+class CliParserRunContext {
+    constructor(parser) {
+        this.input = "";
+        this.captures = new Map();
+        this.brackets = new BracketsManager();
+        this.flags = new FlagsManager();
+        this.parser = parser;
+    }
+    resolveValues(resolver) {
+        const map = new Map();
+        const captures = this.captures;
+        for (const key of captures.keys()) {
+            const value = resolver(captures.get(key));
+            map.set(key, value);
+        }
+        return map;
+    }
+}
+export class CliParser {
+    constructor() {
+        this.context = new CliParserRunContext(this);
+    }
+    // replace brackets to [Bracket*n]
+    processBrackets() {
+        const { context } = this;
+        const { context: bracketsContext, indexes } = context.brackets.parseSafe(context.input);
+        const groups = context.brackets.findPrimaryGroups(bracketsContext);
+        let offset = 0;
+        for (const index in groups) {
+            const group = groups[index];
+            const replacement = context.brackets.toStringGroup(indexes[index]);
+            const length = group.length;
+            this.replaceTextByIndexes(group.indexInText - offset, length, () => replacement);
+            offset += length - replacement.length;
+        }
+        return this;
+    }
+    captureFlags(flags) {
+        const { context } = this;
+        context.flags.captureFlags(flags, context);
+        return this;
+    }
+    captureResidueFlags() {
+        const { context } = this;
+        context.flags.captureResidueFlags(context);
+        return this;
+    }
+    setText(text) {
+        const { context } = this;
+        context.input = text;
+        return this;
+    }
+    captureResidue({ name }) {
+        const { context } = this;
+        const text = context.input;
+        this.replaceTextByIndexes(0, text.length, () => "");
+        context.captures.set(name, new CapturedContent(text).setContextInstance(context));
+        return this;
+    }
+    replaceByMatch(regex) {
+        const { context } = this;
+        const matched = context.input.match(regex);
+        if (!matched) {
+            return null;
+        }
+        const [indexInText, full] = [matched.index, matched[0]];
+        if (indexInText === undefined) {
+            throw new Error("Match without index");
+        }
+        this.replaceTextByIndexes(indexInText, full.length, () => "");
+        return matched;
+    }
+    captureByMatch({ regex, name }) {
+        const { context } = this;
+        const matched = this.replaceByMatch(regex);
+        context.captures.set(name, matched ? new CapturedContent(matched).setContextInstance(context) : null);
+        return this;
+    }
+    replaceTextByIndexes(start, length, replacer) {
+        const { context } = this;
+        const before = context.input.slice(0, start);
+        const after = context.input.slice(start + length);
+        const replaced = replacer(context.input.slice(start, start + length));
+        context.input = `${before}${replaced}${after}`;
+    }
+    collect() {
+        return this.context;
+    }
+}
+CliParser.CliParserRunContext = CliParserRunContext;
+CliParser.CapturedContent = CapturedContent;
+CliParser.BracketsManager = BracketsManager;
+CliParser.FlagsManager = FlagsManager;

package/lib/primitives/mod.d.ts

@@ -1,4 +1,6 @@
-export * from './TextTableBuilder.js';
+export * from "./TextTableBuilder.js";
+export * from "./BracketsParser.js";
+export * from "./CliParser.js";
 interface IEndingOptions {
     unite?: (quantity: number, word: string) => string;
 }

package/lib/primitives/mod.js

@@ -1,4 +1,6 @@
-export * from './TextTableBuilder.js';
+export * from "./TextTableBuilder.js";
+export * from "./BracketsParser.js";
+export * from "./CliParser.js";
 function ending(quantity = 0, base, multiple, alone, double, options = {}) {
     if (isNaN(quantity))
         return NaN;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zoodogood/utils",
   "type": "module",
-  "version": "1.1.3-change.1055",
+  "version": "1.2.0-change.1444",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -10,8 +10,10 @@
     "test": "vitest run",
     "docs-build": "cd ./docs && retype build  --output ./public",
     "docs-watch": "cd ./docs && retype watch",
-    "prepack": "yarn build && yarn test",
-    "build": "tsc"
+    "prepack": "yarn build && yarn test && yarn docs-build",
+    "build": "tsc",
+    "tsc": "tsc",
+    "vitest": "vitest"
   },
   "typings": "lib/index",
   "exports": {
@@ -32,6 +34,7 @@
     "@types/node": "^20.5.9",
     "@typescript-eslint/eslint-plugin": "^6.13.1",
     "@typescript-eslint/parser": "^6.13.1",
+    "@vitest/ui": "^1.2.1",
     "discord-api-types": "^0.37.65",
     "discord.js": "^14.13.0",
     "eslint": "^8.54.0",