@zoodogood/utils 1.0.2 → 1.0.4-change.334

package/lib/discordjs/mod.d.ts

@@ -0,0 +1,37 @@
+export function CreateMessage({ content, title, url, author, thumbnail, description, color, fields, image, video, footer, timestamp, ephemeral, fetchReply, components, files, reference }: {
+    content: any;
+    title: any;
+    url: any;
+    author: any;
+    thumbnail: any;
+    description: any;
+    color: any;
+    fields: any;
+    image: any;
+    video: any;
+    footer: any;
+    timestamp: any;
+    ephemeral: any;
+    fetchReply: any;
+    components: any;
+    files: any;
+    reference: any;
+}): {
+    embeds: EmbedBuilder[];
+    files: any;
+    reply: {
+        messageReference: any;
+    };
+    components: any;
+    content: any;
+    ephemeral: any;
+    fetchReply: any;
+};
+export function CreateModal({ title, customId, components }: {
+    title: any;
+    customId: any;
+    components: any;
+}): import("discord.js").APIModalInteractionResponseCallbackData;
+export function SimplifyComponents(data: any): any;
+export function isEmptyEmbed(embed: any): boolean;
+import { EmbedBuilder } from 'discord.js';

package/lib/discordjs/mod.js

@@ -0,0 +1,79 @@
+import { EmbedBuilder, ModalBuilder, resolveColor, ActionRow } from 'discord.js';
+import { ComponentType } from 'discord-api-types/v10';
+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;
+}
+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;
+    const isActionRow = (component) => component instanceof Array && isComponent(component.at(0)) || component instanceof ActionRow;
+    const isComponents = (component) => component.length && isActionRow(component.at(0));
+    const argumentType = [
+        isComponent(data),
+        isActionRow(data),
+        isComponents(data)
+    ].findIndex(Boolean);
+    if (argumentType === -1)
+        throw new TypeError("expected component");
+    const inArray = (component) => [component];
+    const arrayToActionRow = (componentsArray) => {
+        if (componentsArray.type === ComponentType.ActionRow)
+            return componentsArray;
+        return { type: ComponentType.ActionRow, components: componentsArray };
+    };
+    const actionRowInArray = (actionRow) => [actionRow];
+    if (argumentType <= 0)
+        data = inArray(data);
+    if (argumentType <= 1)
+        data = actionRowInArray(data);
+    data = data.map(arrayToActionRow);
+    return data;
+}
+export { CreateMessage, CreateModal, SimplifyComponents, isEmptyEmbed };

package/lib/nodejs/getChildProcessUtils.d.ts

@@ -1,10 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { ChildProcessWithoutNullStreams } from "child_process";
+import EventsEmitter from "events";
+interface IContext {
+    exitter: {
+        resolve: any;
+        reject: any;
+    };
+    whenEnd: Promise<unknown>;
+    child: ChildProcessWithoutNullStreams;
+    emitter: EventsEmitter;
+    outString: string;
+}
 interface IParams {
     root: string;
     logger?: boolean;
 }
 declare const _default: ({ root, logger }: IParams) => {
-    run: (command: string, params: string[]) => Promise<unknown>;
-    info: (string: string) => Promise<void>;
+    run: (command: string, params: string[]) => IContext;
+    info: (log: string) => void;
     _npm: string;
 };
 export default _default;

package/lib/nodejs/getChildProcessUtils.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { spawn } from "child_process";
 import EventsEmitter from "events";
 export default ({ root, logger = false }) => {
@@ -15,16 +6,16 @@ export default ({ root, logger = false }) => {
     const EventsCallbacks = [
         {
             key: "stdoutError",
-            callback({ exitData }, error) {
+            callback({ exitter }, error) {
                 logger && info(`Error: ${error.message}`);
-                exitData.reject(error);
+                exitter.reject(error);
             },
         },
         {
             key: "stderrError",
-            callback({ exitData }, error) {
+            callback({ exitter }, error) {
                 logger && info(`Error: ${error.message}`);
-                exitData.reject(error);
+                exitter.reject(error);
             },
         },
         {
@@ -53,34 +44,35 @@ export default ({ root, logger = false }) => {
         },
         {
             key: "exit",
-            callback({ exitData, outString }) {
-                exitData.resolve(outString);
+            callback({ exitter, outString }) {
+                exitter.resolve(outString);
             },
         },
         {
             key: "error",
-            callback({ exitData }, error) {
+            callback({ exitter }, error) {
                 logger && info(`Error: ${error.message}`);
-                exitData.reject(error);
+                exitter.reject(error);
             },
         },
     ];
-    const info = (string) => __awaiter(void 0, void 0, void 0, function* () { return console.info(`\x1b[1m${string}\x1b[22m`); });
-    const run = (command, params) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = (log) => console.info(`\x1b[1m${log}\x1b[22m`);
+    const run = (command, params) => {
         const child = spawn(command, params, { cwd: root });
-        const exitData = { resolve: null, reject: null };
-        const promise = new Promise((resolve, reject) => Object.assign(exitData, { resolve, reject }));
+        const exitter = { resolve: null, reject: null };
+        const promise = new Promise((resolve, reject) => Object.assign(exitter, { resolve, reject }));
         const emitter = new EventsEmitter();
         const outString = "";
+        const context = {
+            exitter,
+            whenEnd: promise,
+            child,
+            emitter,
+            outString,
+        };
         const events = Object.fromEntries(EventsCallbacks.map(({ callback, key }) => [
             key,
-            callback.bind(null, {
-                exitData,
-                promise,
-                child,
-                emitter,
-                outString,
-            }),
+            callback.bind(null, context),
         ]));
         (() => {
             child.stdout.on("error", events.stdoutError);
@@ -89,7 +81,7 @@ export default ({ root, logger = false }) => {
             child.stderr.on("data", events.stderrData);
             child.on("error", events.error);
             child.on("message", events.message);
-            child.on("exitData", events.exitData);
+            child.on("exit", events.exit);
         })();
         promise.finally(() => {
             child.stdout.removeListener("error", events.stdoutError);
@@ -98,9 +90,9 @@ export default ({ root, logger = false }) => {
             child.stderr.removeListener("data", events.stderrData);
             child.removeListener("error", events.error);
             child.removeListener("message", events.message);
-            child.removeListener("exitData", events.exitData);
+            child.removeListener("exit", events.exit);
         });
-        return promise;
-    });
+        return context;
+    };
     return { run, info, _npm };
 };

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

package/lib/objectives/mod.js

@@ -1,6 +1,7 @@
 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)
         .filter(([key, value], i) => filter(key, value, i));

package/lib/objectives/rangeToArray.d.ts

@@ -0,0 +1 @@
+export declare function rangeToArray([min, max]: [number, number]): number | number[];

package/lib/objectives/rangeToArray.js

@@ -0,0 +1,6 @@
+export function rangeToArray([min, max]) {
+    if (isNaN(min) || isNaN(max)) {
+        return NaN;
+    }
+    return [...new Array(max - min + 1)].map((_, index) => index + min);
+}

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "@zoodogood/utils",
   "type": "module",
-  "version": "1.0.2",
+  "version": "1.0.4-change.334",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "homepage": "https://zoodogood.github.io/utils",
   "scripts": {
-    "test": "node index",
-    "docs-build": "cd ./docs & retype build  --output ./public"
+    "test": "vitest",
+    "docs-build": "cd ./docs && retype build  --output ./public",
+    "docs-watch": "cd ./docs && retype watch",
+    "prepack": "tsc",
+    "build": "tsc"
   },
   "typings": "lib/index",
   "exports": {
@@ -28,8 +31,9 @@
   "devDependencies": {
     "@types/node": "^20.5.9",
     "discord.js": "^14.13.0",
-    "retype": "^0.2.0",
-    "typescript": "^5.2.2"
+    "retypeapp-linux-x64": "^3.3.0",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.5"
   },
   "peerDependencies": {
     "discord.js": "=>14.x.x"
@@ -39,11 +43,21 @@
   ],
   "typesVersions": {
     ">=4.2": {
-      "*": ["lib/index.d.ts"],
-      "primitives": ["lib/primitives/mod.d.ts"],
-      "objectives": ["lib/objectives/mod.d.ts"],
-      "discordjs": ["lib/discordjs/mod.d.ts"],
-      "nodejs": ["lib/nodejs/mod.d.ts"]
+      "*": [
+        "lib/index.d.ts"
+      ],
+      "primitives": [
+        "lib/primitives/mod.d.ts"
+      ],
+      "objectives": [
+        "lib/objectives/mod.d.ts"
+      ],
+      "discordjs": [
+        "lib/discordjs/mod.d.ts"
+      ],
+      "nodejs": [
+        "lib/nodejs/mod.d.ts"
+      ]
     }
   }
 }

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.