fixed compiling

.gitignore

@@ -1,2 +1 @@
-node_modules
+node_modules
-lib

discord/buildexample.js

@@ -0,0 +1,16 @@
+const { build } = require('esbuild');
+
+const define = {
+    TOKEN: `"${process.argv[2]}"`
+};
+
+build({
+    entryPoints: ['examples/main.ts'],
+    outfile: 'examples/main.js',
+
+    target: 'es6',
+    platform: 'node',
+    format: 'cjs',
+
+    define
+});

discord/lib/index.d.ts

@@ -0,0 +1,19 @@
+import { basicObject, basicObjectStringable } from '../..';
+import { embedDataType } from './types';
+/**
+ * reads language json as an object (could be embed or just string)
+ * @param id ex: discord.error.noActiveQueue
+ * @param argsraw list of key/value pairs to represent template values
+ * @param otherOptions values to be passed through to the return value
+ * @returns language value, defaults to `id` parameter
+ */
+declare function getEmbed(id: string, argsraw?: basicObjectStringable, otherOptions?: basicObject): embedDataType;
+export * from '../..';
+export * from './types';
+export * from './util';
+declare const _default: {
+    getEmbed: typeof getEmbed;
+    setLang: typeof import("../..").setLang;
+    get: (id: string, argsraw?: basicObjectStringable | undefined) => string;
+};
+export default _default;

discord/lib/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("../..");
+const util_1 = require("./util");
+/**
+ * reads language json as an object (could be embed or just string)
+ * @param id ex: discord.error.noActiveQueue
+ * @param argsraw list of key/value pairs to represent template values
+ * @param otherOptions values to be passed through to the return value
+ * @returns language value, defaults to `id` parameter
+ */
+function getEmbed(id, argsraw = {}, otherOptions = {}) {
+    const args = (0, __1.convertBasicObject)(argsraw), embedData = Object.assign(Object.assign({}, otherOptions), { embeds: [] });
+    const keySpl = id.split('.').map(k => k.trim()).filter(k => k);
+    let finding = (0, __1.getLang)();
+    for (const key of keySpl) {
+        if (key in finding) {
+            const found = finding[key];
+            if (typeof found === 'string') {
+                embedData.content = (0, __1.template)(found, args);
+                break;
+            }
+            if (found.embed === true) {
+                const embedObj = found, { content } = embedObj, embed = (0, util_1.embedObjEmbed)(embedObj, args);
+                embedData.embeds.push(embed);
+                if (content !== undefined)
+                    embedData.content = content;
+                return embedData;
+            }
+            finding = found;
+        }
+        else
+            break;
+    }
+    return embedData;
+}
+__exportStar(require("../.."), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./util"), exports);
+exports.default = Object.assign(Object.assign({}, __1.default), { getEmbed });

discord/lib/types.d.ts

@@ -0,0 +1,8 @@
+import { MessageEmbed } from "discord.js";
+/**
+ * an object that contains embeds and can be passed directly to methods like `Discord.TextChannel.send()`
+ */
+export interface embedDataType {
+    content?: string;
+    embeds: MessageEmbed[];
+}

discord/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

discord/lib/util.d.ts

@@ -0,0 +1,6 @@
+import { MessageEmbed } from 'discord.js';
+import { basicObjectString, embedObject } from '../..';
+/**
+ * converts embedObj to Discord.MessageEmbed
+ */
+export declare function embedObjEmbed(embedObj: embedObject, args?: basicObjectString): MessageEmbed;

discord/lib/util.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embedObjEmbed = void 0;
+const discord_js_1 = require("discord.js");
+const __1 = require("../..");
+/**
+ * converts embedObj to Discord.MessageEmbed
+ */
+function embedObjEmbed(embedObj, args = {}) {
+    const embed = new discord_js_1.MessageEmbed(), { author, color, description, fields, footer, image, thumbnail, timestamp, title, url } = embedObj;
+    if (author !== undefined) {
+        let authorFix;
+        if (typeof author === 'string')
+            authorFix = {
+                name: (0, __1.template)(author, args)
+            };
+        else {
+            const { name, iconURL, url } = author;
+            authorFix = {
+                name: (0, __1.template)(name, args)
+            };
+            if (iconURL !== undefined)
+                authorFix.iconURL = (0, __1.template)(iconURL, args);
+            if (url !== undefined)
+                authorFix.url = (0, __1.template)(url, args);
+        }
+        embed.setAuthor(authorFix);
+    }
+    if (footer !== undefined) {
+        let footerFix;
+        if (typeof footer === 'string') {
+            footerFix = {
+                text: (0, __1.template)(footer, args)
+            };
+        }
+        else {
+            const { text, iconURL } = footer;
+            footerFix = {
+                text: (0, __1.template)(text, args)
+            };
+            if (iconURL !== undefined)
+                footerFix.iconURL = (0, __1.template)(iconURL, args);
+        }
+        embed.setFooter(footerFix);
+    }
+    if (color !== undefined)
+        embed.setColor((0, __1.resolveColor)((0, __1.template)(color, args)));
+    if (description !== undefined)
+        embed.setDescription((0, __1.template)((0, __1.bigString)(description), args));
+    if (image !== undefined)
+        embed.setImage((0, __1.template)(image, args));
+    if (thumbnail !== undefined)
+        embed.setThumbnail((0, __1.template)(thumbnail, args));
+    if (title !== undefined)
+        embed.setTitle((0, __1.template)(title, args));
+    if (url !== undefined)
+        embed.setURL((0, __1.template)(url, args));
+    if (timestamp === true)
+        embed.setTimestamp();
+    else if (typeof timestamp === 'string')
+        embed.setTimestamp(new Date((0, __1.template)(timestamp, args)));
+    else if (timestamp !== false)
+        embed.setTimestamp(timestamp);
+    fields === null || fields === void 0 ? void 0 : fields.forEach(field => {
+        embed.addField((0, __1.template)(field.name, args), (0, __1.template)((0, __1.bigString)(field.value), args), field.inline);
+    });
+    return embed;
+}
+exports.embedObjEmbed = embedObjEmbed;

discord/package.json

@@ -0,0 +1,4 @@
+{
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts"
+}

discord/src/index.ts

@@ -0,0 +1,65 @@
+import Lang, { basicObject, basicObjectStringable, convertBasicObject, embedObject, getLang, LangObj, template } from '../..';
+import { embedDataType } from './types';
+import { embedObjEmbed } from './util';
+
+/**
+ * reads language json as an object (could be embed or just string)
+ * @param id ex: discord.error.noActiveQueue
+ * @param argsraw list of key/value pairs to represent template values
+ * @param otherOptions values to be passed through to the return value
+ * @returns language value, defaults to `id` parameter
+ */
+function getEmbed(id: string, argsraw: basicObjectStringable = {}, otherOptions: basicObject = {}): embedDataType {
+
+    const args = convertBasicObject(argsraw),
+        embedData: embedDataType = {
+        ...otherOptions,
+        embeds: []
+    };
+    
+    const keySpl = id.split('.').map(k => k.trim()).filter(k => k);
+
+    let finding = getLang();
+
+    for (const key of keySpl) {
+
+        if (key in finding) {
+
+            const found = finding[key];
+
+            if (typeof found === 'string') {
+                embedData.content = template(found, args);
+                break;
+            }
+
+            if (found.embed === true) {
+                const embedObj = found as embedObject,
+                    {content} = embedObj,
+                    embed = embedObjEmbed(embedObj, args);
+
+                embedData.embeds.push(embed);
+
+                if (content !== undefined)
+                    embedData.content = content;
+
+                return embedData;
+            }
+            
+            finding = found as LangObj;
+
+        } else
+            break;
+        
+    }
+
+    return embedData;
+}
+
+export * from '../..';
+export * from './types';
+export * from './util';
+
+export default {
+    ...Lang,
+    getEmbed
+};

discord/src/types.ts

@@ -6,4 +6,4 @@ import { MessageEmbed } from "discord.js";
 export interface embedDataType {
     content?: string,
     embeds: MessageEmbed[]
-}
+}

discord/src/util.ts

@@ -1,8 +1,5 @@
 import { MessageEmbed } from 'discord.js';
-import { template, resolveColor, bigString } from '..';
+import { authorData, basicObjectString, bigString, embedObject, footerData, resolveColor, template } from '../..';
-import { embedObject, basicObjectString, authorData, footerData } from '../types';
-
-export * from "..";
 
 /**
  * converts embedObj to Discord.MessageEmbed
@@ -96,4 +93,4 @@ export function embedObjEmbed(embedObj: embedObject, args: basicObjectString = {
     });
 
     return embed;
-}
+}

discord/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./lib",
+    "rootDir": "./src",
+    "strict": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}

lib/index.d.ts

@@ -0,0 +1,17 @@
+import { basicObjectStringable, LangObj } from './types';
+export declare function setLang(lang: LangObj): void;
+export declare function getLang(): LangObj;
+/**
+ * reads language json (just strings)
+ * @param id ex: discord.error.noActiveQueue
+ * @param argsraw list of key/value pairs to represent template values
+ * @returns language value, defaults to `id` parameter
+ */
+declare function get(id: string, argsraw?: basicObjectStringable): string;
+declare const _default: {
+    setLang: typeof setLang;
+    get: typeof get;
+};
+export default _default;
+export * from './types';
+export * from './util';

lib/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLang = exports.setLang = void 0;
+const util_1 = require("./util");
+/* MAIN */
+var LANG = {};
+function setLang(lang) {
+    LANG = lang;
+}
+exports.setLang = setLang;
+function getLang() {
+    return LANG;
+}
+exports.getLang = getLang;
+/**
+ * reads language json (just strings)
+ * @param id ex: discord.error.noActiveQueue
+ * @param argsraw list of key/value pairs to represent template values
+ * @returns language value, defaults to `id` parameter
+ */
+function get(id, argsraw = {}) {
+    const args = (0, util_1.convertBasicObject)(argsraw), keySpl = id.split('.').map(k => k.trim()).filter(k => k);
+    let finding = LANG;
+    for (const key of keySpl) {
+        if (key in finding) {
+            const found = finding[key];
+            if (typeof found === 'string')
+                return (0, util_1.template)(found, args);
+            if (found.embed === true)
+                return (0, util_1.embedObjStr)(found, args, id);
+            finding = found;
+        }
+        else
+            break;
+    }
+    return id;
+}
+exports.default = {
+    setLang,
+    get
+};
+__exportStar(require("./types"), exports);
+__exportStar(require("./util"), exports);

lib/types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * any indexable object
+ */
+export declare type basicObject = {
+    [keys: string]: any;
+};
+/**
+ * any indexable object with string values
+ */
+export declare type basicObjectStringable = {
+    [keys: string]: string | number | boolean | null;
+};
+export declare type basicObjectString = {
+    [keys: string]: string;
+};
+/**
+ * an abstract version of strings
+ */
+export declare type bigStringType = string | string[];
+/**
+ * a representation of an author in the LANG object
+ *
+ * `LANG > Language > Embed > Field`
+ */
+export interface embedField {
+    name: string;
+    value: bigStringType;
+    inline?: boolean;
+}
+/**
+ * a representation of an author in the LANG object
+ *
+ * `LANG > Language > Embed > Author`
+ */
+export interface authorData {
+    name: string;
+    url?: string;
+    iconURL?: string;
+}
+/**
+ * a representation of a footer in the LANG object
+ *
+ * `LANG > Language > Embed > Footer`
+ */
+export interface footerData {
+    text: string;
+    iconURL?: string;
+}
+/**
+ * a representation of an embed in the LANG object
+ *
+ * `LANG > Language > Embed`
+ */
+export interface embedObject {
+    embed: true;
+    content?: string;
+    title?: string;
+    description?: bigStringType;
+    /**
+     * URL
+     */
+    url?: string;
+    /**
+     * #FFFFFF
+     */
+    color?: string;
+    footer?: string | footerData;
+    thumbnail?: string;
+    /**
+     * URL
+     */
+    image?: string;
+    /**
+     * URL
+     */
+    author?: string | authorData;
+    fields?: embedField[];
+    timestamp?: boolean | string | number;
+}
+/**
+ * a specific language in the LANG object
+ *
+ * `LANG > Language`
+ */
+export declare type LangObj = {
+    [keys: string]: LangObj | embedObject | string;
+};

lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

lib/util.d.ts

@@ -0,0 +1,22 @@
+import { basicObject, basicObjectString, basicObjectStringable, bigStringType, embedObject } from './types';
+/**
+ *
+ * @param str
+ * @param args
+ * @returns
+ */
+export declare function template(str: string, args: basicObject): string;
+/**
+ * converts bigString to string
+ */
+export declare function bigString(bigStr: bigStringType): string;
+/**
+ * converts Hex Color string to an RGB array
+ */
+export declare function resolveColor(color: string): [number, number, number];
+/**
+ * converts embedObj to a string if applicable
+ * @param fallback the string to use if no valid strings can be found
+ */
+export declare function embedObjStr(embedObj: embedObject, args?: basicObjectString, fallback?: string): string;
+export declare function convertBasicObject(obj: basicObjectStringable): basicObjectString;

lib/util.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBasicObject = exports.embedObjStr = exports.resolveColor = exports.bigString = exports.template = void 0;
+/**
+ *
+ * @param str
+ * @param args
+ * @returns
+ */
+function template(str, args) {
+    return str.replace(/{\w+}/g, str => {
+        const key = str.substring(1, str.length - 1);
+        if (key in args)
+            return args[key];
+        return key;
+    });
+}
+exports.template = template;
+/**
+ * converts bigString to string
+ */
+function bigString(bigStr) {
+    if (Array.isArray(bigStr))
+        return bigStr.join('\n');
+    return bigStr;
+}
+exports.bigString = bigString;
+/**
+ * converts Hex Color string to an RGB array
+ */
+function resolveColor(color) {
+    color = color.replace(/[^0-9a-f]/gi, '');
+    const colorNum = [0, 0, 0];
+    if (color.length === 3 || color.length === 6) {
+        const colorSplRaw = /([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})/.exec(color);
+        if (!colorSplRaw)
+            return colorNum;
+        const colorSpl = colorSplRaw.slice(1, 4);
+        if (color.length === 3)
+            colorSpl.map(c => c + c);
+        for (let i = 0; i < colorSpl.length && i < colorNum.length; i++)
+            colorNum[i] = parseInt(colorSpl[i], 16);
+    }
+    return colorNum;
+}
+exports.resolveColor = resolveColor;
+/**
+ * converts embedObj to a string if applicable
+ * @param fallback the string to use if no valid strings can be found
+ */
+function embedObjStr(embedObj, args = {}, fallback = '') {
+    if (embedObj.content !== undefined)
+        return template(bigString(embedObj.content), args);
+    if (embedObj.description !== undefined)
+        return template(bigString(embedObj.description), args);
+    return fallback;
+}
+exports.embedObjStr = embedObjStr;
+function convertBasicObject(obj) {
+    let ret = {};
+    for (const key in obj) {
+        const val = obj[key];
+        if (typeof val === 'string')
+            ret[key] = val;
+        else if (typeof val === 'boolean')
+            ret[key] = val.toString();
+        else if (typeof val === 'number')
+            ret[key] = val.toString();
+        else
+            ret[key] = '';
+    }
+    return ret;
+}
+exports.convertBasicObject = convertBasicObject;

package.json

@@ -6,8 +6,7 @@
     "types": "lib/index.d.ts",
     "devDependencies": {},
     "scripts": {
-        "build": "tsc",
+        "build": "tsc && cd discord && tsc && cd .."
-		"prepare": "npm run build"
     },
     "repository": {
         "type": "git",

src/index.ts

@@ -1,76 +1,56 @@
+import { basicObjectStringable, embedObject, LangObj } from './types';
+import { convertBasicObject, embedObjStr, template } from './util';
 
-import { authorData, basicObject, basicObjectString, bigStringType, embedObject, footerData } from './types';
+/* MAIN */
+var LANG: LangObj = {};
 
-/**
+export function setLang(lang: LangObj) {
- * 
+    LANG = lang;
- * @param str 
+}
- * @param args 
- * @returns 
- */
-export function template(str: string, args: basicObject): string {
-
-    return str.replace(/{\w+}/g, str => {
-
-        const key = str.substring(1, str.length-1);
-
-        if (key in args)
-            return args[key];
-
-        return key;
-
-    });
 
+export function getLang(): LangObj {
+    return LANG;
 }
 
 /**
- * converts bigString to string
+ * reads language json (just strings)
+ * @param id ex: discord.error.noActiveQueue
+ * @param argsraw list of key/value pairs to represent template values
+ * @returns language value, defaults to `id` parameter
  */
-export function bigString(bigStr: bigStringType): string {
+function get(id: string, argsraw: basicObjectStringable = {}): string {
-    if (Array.isArray(bigStr))
-        return bigStr.join('\n');
-    return bigStr;
-}
 
+    const args = convertBasicObject(argsraw),
+        keySpl = id.split('.').map(k => k.trim()).filter(k => k);
 
-/**
+    let finding = LANG;
- * converts Hex Color string to an RGB array
- */
-export function resolveColor(color: string): [number, number, number] {
-    color = color.replace(/[^0-9a-f]/gi, '');
 
-    const colorNum: [number, number, number] = [0, 0, 0];
+    for (const key of keySpl) {
 
-    if (color.length === 3 || color.length === 6) {
+        if (key in finding) {
 
-        const colorSplRaw = /([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})/.exec(color);
+            const found = finding[key];
 
-        if (!colorSplRaw)
+            if (typeof found === 'string')
-            return colorNum;
+                return template(found, args);
 
-        const colorSpl = colorSplRaw.slice(1, 4);
+            if (found.embed === true)
-
+                return embedObjStr(found as embedObject, args, id);
-        if (color.length === 3)
+                
-            colorSpl.map(c => c + c);
+            finding = found as LangObj;
-
-        for (let i = 0; i < colorSpl.length && i < colorNum.length; i++)
-            colorNum[i] = parseInt(colorSpl[i], 16);
 
+        } else
+            break;
+        
     }
 
-    return colorNum;
+    return id;
 }
 
-/**
+export default {
- * converts embedObj to a string if applicable
+    setLang,
- * @param fallback the string to use if no valid strings can be found
+    get
- */
+};
-export function embedObjStr(embedObj: embedObject, args: basicObjectString = {}, fallback = ''): string {
 
-    if (embedObj.content !== undefined)
+export * from './types';
-        return template(bigString(embedObj.content), args);
+export * from './util';
-
-    if (embedObj.description !== undefined)
-        return template(bigString(embedObj.description), args);
-
-    return fallback;
-}

src/types.ts

@@ -1,5 +1,3 @@
-
-
 /**
  * any indexable object
  */
@@ -89,11 +87,4 @@ export interface embedObject {
  * 
  * `LANG > Language`
  */
-export type LangObj = { [keys:string]: LangObj | embedObject | string }
+export type LangObj = { [keys:string]: LangObj | embedObject | string }
-
-/**
- * the entire LANG object
- * 
- * `LANG`
- */
-export type LangObjWhole = { [langid:string]: LangObj }

src/util.ts

@@ -0,0 +1,91 @@
+import { basicObject, basicObjectString, basicObjectStringable, bigStringType, embedObject } from './types';
+
+/**
+ * 
+ * @param str 
+ * @param args 
+ * @returns 
+ */
+export function template(str: string, args: basicObject): string {
+
+    return str.replace(/{\w+}/g, str => {
+
+        const key = str.substring(1, str.length-1);
+
+        if (key in args)
+            return args[key];
+
+        return key;
+
+    });
+
+}
+
+/**
+ * converts bigString to string
+ */
+export function bigString(bigStr: bigStringType): string {
+    if (Array.isArray(bigStr))
+        return bigStr.join('\n');
+    return bigStr;
+}
+
+
+/**
+ * converts Hex Color string to an RGB array
+ */
+export function resolveColor(color: string): [number, number, number] {
+    color = color.replace(/[^0-9a-f]/gi, '');
+
+    const colorNum: [number, number, number] = [0, 0, 0];
+
+    if (color.length === 3 || color.length === 6) {
+
+        const colorSplRaw = /([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})/.exec(color);
+
+        if (!colorSplRaw)
+            return colorNum;
+
+        const colorSpl = colorSplRaw.slice(1, 4);
+
+        if (color.length === 3)
+            colorSpl.map(c => c + c);
+
+        for (let i = 0; i < colorSpl.length && i < colorNum.length; i++)
+            colorNum[i] = parseInt(colorSpl[i], 16);
+
+    }
+
+    return colorNum;
+}
+
+/**
+ * converts embedObj to a string if applicable
+ * @param fallback the string to use if no valid strings can be found
+ */
+export function embedObjStr(embedObj: embedObject, args: basicObjectString = {}, fallback = ''): string {
+
+    if (embedObj.content !== undefined)
+        return template(bigString(embedObj.content), args);
+
+    if (embedObj.description !== undefined)
+        return template(bigString(embedObj.description), args);
+
+    return fallback;
+}
+
+export function convertBasicObject(obj: basicObjectStringable): basicObjectString {
+    let ret: basicObjectString = {};
+    for (const key in obj) {
+        const val = obj[key];
+        if (typeof val === 'string')
+            ret[key] = val;
+        else if (typeof val === 'boolean')
+            ret[key] = val.toString();
+        else if (typeof val === 'number')
+            ret[key] = val.toString();
+        else
+            ret[key] = '';
+    }
+    return ret;
+}