@draggable/i18n 1.0.4

package/README.md

@@ -0,0 +1,70 @@
+# i18n ![NPM Version](https://img.shields.io/npm/v/%40draggable%2Fi18n)
+
+
+Add multi-lingual support to any JavaScript app or module with this light-weight package.
+
+### Features:
+
+- Isomorphic/Universal
+- easy translation of static text files
+  - benefits: anyone can translate, no more xliff
+  - reduced margin of error.
+- Variable support
+- Dependency free
+- Fast
+
+## Usage
+
+```javascript
+import { I18n } from '@draggable/i18n'
+
+const i18nOptions = {
+  extension: '.lang', // extnsion used by your language files, defaults to ".lang"
+  location: 'https://location.of/language/files/', // absolute or relative url to language files
+  langs: [
+    // locales you would like to be active
+    'en-US',
+    'pt-BR',
+    'de-DE', // will attempt to load `https://location.of/language/files/de-DE.lang` with current config
+  ],
+  locale: 'en-US', // default locale
+  override: {
+    'en-US': {
+      autocomplete: 'Autofinish', // override individual keys or provide entire language definition
+    },
+  },
+}
+const i18n = new I18n(i18nOptions)
+```
+
+... then in your app
+
+```jsx
+<label>{i18n.get('addOption')}</label>
+```
+
+### Add a Language after initialization
+
+```javascript
+i18n.addLanguage('fr-FR', {
+  addOption: 'Ajouter une option',
+})
+```
+
+### Process a confige file
+
+```javascript
+i18n.processConfig(configFileString)
+```
+
+### Example `.lang` file
+
+```txt
+de-DE = Deutsch
+en-US = German
+
+addOption = Option hinzufügen
+allFieldsRemoved = Alle Felder wurden entfernt.
+allowMultipleFiles = Upload mehrerer Dateien erlauben
+autocomplete = Autovervollständigung
+```

package/dist/i18n.cjs.min.js

@@ -0,0 +1,9 @@
+
+/**
+@draggable/i18n - https://github.com/Draggable/i18n
+Version: 1.0.3
+Author: Draggable https://draggable.io
+*/
+
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e={},t=Object.freeze({method:"GET",body:""});const s=(e,t)=>{const s=[];e.on("data",(e=>s.push(e))),e.on("end",(()=>{const n=Buffer.concat(s),a={ok:e.statusCode>=200&&e.statusCode<300,status:e.statusCode,statusText:e.statusMessage,headers:new Map(Object.entries(e.headers)),body:n,arrayBuffer:()=>Promise.resolve(n),json:()=>Promise.resolve(JSON.parse(n.toString()))};t(a)}))},n={extension:".lang",location:"assets/lang/",langs:["en-US"],locale:"en-US",override:{}};class a{constructor(e=n){this.langs=Object.create(null),this.loaded=[],this.processConfig(e)}processConfig(e){const{location:t,...s}={...n,...e},a=t.replace(/\/?$/,"/");this.config={location:a,...s};const{override:o,preloaded:r={}}=this.config,i=Object.entries(this.langs).concat(Object.entries(o||r));this.langs=i.reduce(((e,[t,s])=>(e[t]=this.applyLanguage(t,s),e)),{}),this.locale=this.config.locale||this.config.langs[0]}init(e){return this.processConfig({...this.config,...e}),this.setCurrent(this.locale)}addLanguage(e,t={}){t="string"==typeof t?a.processFile(t):t,this.applyLanguage(e,t),this.config.langs.push("locale")}getValue(e,t=this.locale){var s;return(null==(s=this.langs[t])?void 0:s[e])||this.getFallbackValue(e)}getFallbackValue(e){const t=Object.values(this.langs).find((t=>t[e]));return null==t?void 0:t[e]}makeSafe(e){const t={"{":"\\{","}":"\\}","|":"\\|"};return e=e.replace(/[{}|]/g,(e=>t[e])),new RegExp(e,"g")}put(e,t){return this.current[e]=t,t}get(e,t){const s=this;let n=this.getValue(e);if(!n)return;const a=n.match(/\{[^}]+?\}/g);if(t&&a)if("object"==typeof t)for(const o of a){const e=o.substring(1,o.length-1);n=n.replace(s.makeSafe(o),t[e]||"")}else n=n.replace(/\{[^}]+?\}/g,t);return n}static processFile(e){return a.fromFile(e.replace(/\n\n/g,"\n"))}static fromFile(e){const t=e.split("\n"),s={};for(let n,a=0;a<t.length;a++){n=/^(.+?) *?= *?([^\n]+)/.exec(t[a]),n&&(s[n[1]]=n[2].replace(/(^\s+|\s+$)/g,""))}return s}loadLang(n,a=!0){const o=this;return new Promise((function(r,i){if(-1!==o.loaded.indexOf(n)&&a)return o.applyLanguage(o.langs[n]),r(o.langs[n]);return function(n,a={}){const o={...t,...a},r=(n.startsWith("https"),e);return new Promise(((e,t)=>{const a=r.request(n,o,(t=>{s(t,e)}));a.on("error",(e=>t(new Error(e.message)))),(null==o?void 0:o.body)&&a.write(o.body),a.end()}))}([o.config.location,n,o.config.extension].join("")).then((({data:e})=>{const t=o.processFile(e);return o.applyLanguage(n,t),o.loaded.push(n),r(o.langs[n])})).catch((()=>{const e=o.applyLanguage(n);r(e)}))}))}applyLanguage(e,t={}){const s=this.config.override[e]||{},n=this.langs[e]||{};return this.langs[e]={...n,...t,...s},this.langs[e]}get getLangs(){return this.config.langs}async setCurrent(e="en-US"){return await this.loadLang(e),this.locale=e,this.current=this.langs[e],this.current}}const o=new a;exports.I18N=a,exports.default=o;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"i18n.cjs.min.js","sources":["../__vite-browser-external","../src/fetch.js","../src/mi18n.js"],"sourcesContent":["export default {}","import https from 'https'\nimport http from 'http'\n\nconst defaultOptions = Object.freeze({ method: 'GET', body: '' })\n/**\n * Fetches a resource from the network.\n *\n * @param {string} url - The URL to fetch.\n * @param {Object} [fetchOptions={}] - The options for the fetch request.\n * @param {Object} [fetchOptions.headers] - Headers to include in the request.\n * @param {string} [fetchOptions.method] - The HTTP method to use (e.g., 'GET', 'POST').\n * @param {string|Buffer} [fetchOptions.body] - The body of the request.\n * @return {Promise<Object>} A promise that resolves to the response object.\n * @return {boolean} return.ok - Indicates if the response status is in the range 200-299.\n * @return {number} return.status - The HTTP status code of the response.\n * @return {string} return.statusText - The HTTP status message of the response.\n * @return {Map<string, string>} return.headers - The headers of the response.\n * @return {Buffer} return.body - The body of the response as a Buffer.\n * @return {function(): Promise<Buffer>} return.arrayBuffer - A function that returns a promise resolving to the body as an ArrayBuffer.\n * @return {function(): Promise<Object>} return.json - A function that returns a promise resolving to the body parsed as JSON.\n */\nexport function fetch(url, fetchOptions = {}) {\n  const options = { ...defaultOptions, ...fetchOptions }\n  const handler = url.startsWith('https') ? https : http\n\n  return new Promise((resolve, reject) => {\n    const request = handler.request(url, options, response => {\n      processResponse(response, resolve)\n    })\n\n    request.on('error', error => reject(new Error(error.message)))\n    if (options?.body) request.write(options.body)\n    request.end()\n  })\n}\n\nconst processResponse = (response, onEnd) => {\n  const data = []\n  response.on('data', chunk => data.push(chunk))\n  response.on('end', () => {\n    const bodyBuffer = Buffer.concat(data)\n    const result = {\n      ok: response.statusCode >= 200 && response.statusCode < 300,\n      status: response.statusCode,\n      statusText: response.statusMessage,\n      headers: new Map(Object.entries(response.headers)),\n      body: bodyBuffer,\n      arrayBuffer: () => Promise.resolve(bodyBuffer),\n      json: () => Promise.resolve(JSON.parse(bodyBuffer.toString())),\n    }\n    onEnd(result)\n  })\n}\n","import { fetch } from './fetch.js'\n\nconst DEFAULT_CONFIG = {\n  extension: '.lang',\n  // local or remote directory containing language files\n  location: 'assets/lang/',\n  // list of available locales, handy for populating selector.\n  langs: ['en-US'],\n  locale: 'en-US', // init with user's preferred language\n  override: {},\n}\n\n/**\n * Main i18n class\n * @class I18N\n * @classdesc methods and data store for i18n\n */\nexport class I18N {\n  /**\n   * Process options and start the module\n   * @param {Object} options\n   */\n  constructor(options = DEFAULT_CONFIG) {\n    this.langs = Object.create(null)\n    this.loaded = []\n    this.processConfig(options)\n  }\n\n  /**\n   * parse and format config\n   * @param {Object} options\n   */\n  processConfig(options) {\n    const { location, ...restOptions } = { ...DEFAULT_CONFIG, ...options }\n    const parsedLocation = location.replace(/\\/?$/, '/')\n    this.config = { location: parsedLocation, ...restOptions }\n    const { override, preloaded = {} } = this.config\n    const allLangs = Object.entries(this.langs).concat(Object.entries(override || preloaded))\n    this.langs = allLangs.reduce((acc, [locale, lang]) => {\n      acc[locale] = this.applyLanguage(locale, lang)\n      return acc\n    }, {})\n    this.locale = this.config.locale || this.config.langs[0]\n  }\n\n  /**\n   * Load language and set default\n   * @param  {Object} options\n   * @return {Promise}        resolves language\n   */\n  init(options) {\n    this.processConfig({ ...this.config, ...options })\n    return this.setCurrent(this.locale)\n  }\n\n  /**\n   * Adds a language to the list of available languages\n   * @param {String} locale\n   * @param {String|Object} lang\n   */\n  addLanguage(locale, lang = {}) {\n    lang = typeof lang === 'string' ? I18N.processFile(lang) : lang\n    this.applyLanguage(locale, lang)\n    this.config.langs.push('locale')\n  }\n\n  /**\n   * get a string from a loaded language file\n   * @param  {String} key  - the key for the string we are trying to retrieve\n   * @param  {String} locale - locale to check for value\n   * @return {String} language string or undefined\n   */\n  getValue(key, locale = this.locale) {\n    const value = this.langs[locale]?.[key]\n    return value || this.getFallbackValue(key)\n  }\n\n  /**\n   * Find a language that has desired key\n   * @param {String} key value key\n   * @return {String} found value or undefined\n   */\n  getFallbackValue(key) {\n    const fallbackLang = Object.values(this.langs).find(lang => lang[key])\n    return fallbackLang?.[key]\n  }\n\n  /**\n   * Escape variable syntax\n   * @param  {String} str\n   * @return {String}     escaped str\n   */\n  makeSafe(str) {\n    const mapObj = {\n      '{': '\\\\{',\n      '}': '\\\\}',\n      '|': '\\\\|',\n    }\n\n    str = str.replace(/[{}|]/g, matched => mapObj[matched])\n\n    return new RegExp(str, 'g')\n  }\n\n  /**\n   * Temporarily put a string into the currently loaded language\n   * @param  {String} key\n   * @param  {String} string\n   * @return {String} string in current language\n   */\n  put(key, string) {\n    this.current[key] = string\n\n    return string\n  }\n\n  /**\n   * Parse arguments for the requested string\n   * @param  {String} key  the key we use to lookup our translation\n   * @param  {multi}  args  string, number or object containing our arguments\n   * @return {String}      updated string translation\n   */\n  get(key, args) {\n    const _this = this\n    let value = this.getValue(key)\n    if (!value) {\n      return\n    }\n\n    const tokens = value.match(/\\{[^}]+?\\}/g)\n\n    if (args && tokens) {\n      if ('object' === typeof args) {\n        for (const token of tokens) {\n          const key = token.substring(1, token.length - 1)\n          value = value.replace(_this.makeSafe(token), args[key] || '')\n        }\n      } else {\n        value = value.replace(/\\{[^}]+?\\}/g, args)\n      }\n    }\n\n    return value\n  }\n\n  /**\n   * Static method: Process a language file from raw text\n   * @param  {String} response\n   * @return {Object} processed language\n   */\n  static processFile(response) {\n    return I18N.fromFile(response.replace(/\\n\\n/g, '\\n'))\n  }\n\n  /**\n   * Static method: Turn raw text from the language files into fancy JSON\n   * @param  {String} rawText\n   * @return {Object} converted language file\n   */\n  static fromFile(rawText) {\n    const lines = rawText.split('\\n')\n    const lang = {}\n\n    for (let matches, i = 0; i < lines.length; i++) {\n      const regex = /^(.+?) *?= *?([^\\n]+)/\n      matches = regex.exec(lines[i])\n      if (matches) {\n        lang[matches[1]] = matches[2].replace(/(^\\s+|\\s+$)/g, '')\n      }\n    }\n\n    return lang\n  }\n\n  /**\n   * Load a remotely stored language file\n   * @param  {String} locale\n   * @param  {Boolean} useCache\n   * @return {Promise}       resolves response\n   */\n  loadLang(locale, useCache = true) {\n    const _this = this\n    return new Promise(function (resolve, reject) {\n      if (_this.loaded.indexOf(locale) !== -1 && useCache) {\n        _this.applyLanguage(_this.langs[locale])\n        return resolve(_this.langs[locale])\n      } else {\n        const langFile = [_this.config.location, locale, _this.config.extension].join('')\n        return fetch(langFile)\n          .then(({ data: lang }) => {\n            const processedFile = _this.processFile(lang)\n            _this.applyLanguage(locale, processedFile)\n            _this.loaded.push(locale)\n            return resolve(_this.langs[locale])\n          })\n          .catch(() => {\n            const lang = _this.applyLanguage(locale)\n            resolve(lang)\n          })\n      }\n    })\n  }\n\n  /**\n   * applies overrides from config\n   * @param {String} locale\n   * @param {Object} lang\n   * @return {Object} overriden language\n   */\n  applyLanguage(locale, lang = {}) {\n    const override = this.config.override[locale] || {}\n    const existingLang = this.langs[locale] || {}\n    this.langs[locale] = { ...existingLang, ...lang, ...override }\n    return this.langs[locale]\n  }\n\n  /**\n   * return currently available languages\n   * @return {Object} all configured languages\n   */\n  get getLangs() {\n    return this.config.langs\n  }\n\n  /**\n   * Attempt to set the current language to the local provided\n   * @param {String}   locale\n   * @return {Promise} language\n   */\n  async setCurrent(locale = 'en-US') {\n    await this.loadLang(locale)\n    this.locale = locale\n    this.current = this.langs[locale]\n\n    return this.current\n  }\n}\n\nexport default new I18N()\n"],"names":["http","defaultOptions","Object","freeze","method","body","processResponse","response","onEnd","data","on","chunk","push","bodyBuffer","Buffer","concat","result","ok","statusCode","status","statusText","statusMessage","headers","Map","entries","arrayBuffer","Promise","resolve","json","JSON","parse","toString","DEFAULT_CONFIG","extension","location","langs","locale","override","I18N","constructor","options","this","create","loaded","processConfig","restOptions","parsedLocation","replace","config","preloaded","allLangs","reduce","acc","lang","applyLanguage","init","setCurrent","addLanguage","processFile","getValue","key","_a","getFallbackValue","fallbackLang","values","find","makeSafe","str","mapObj","matched","RegExp","put","string","current","get","args","_this","value","tokens","match","token","substring","length","fromFile","rawText","lines","split","matches","i","exec","loadLang","useCache","reject","indexOf","url","fetchOptions","handler","startsWith","https","request","error","Error","message","write","end","fetch","join","then","processedFile","catch","existingLang","getLangs","mi18n"],"mappings":"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"}

package/dist/i18n.es.min.js

@@ -0,0 +1,250 @@
+
+/**
+@draggable/i18n - https://github.com/Draggable/i18n
+Version: 1.0.3
+Author: Draggable https://draggable.io
+*/
+
+const http = {};
+const defaultOptions = Object.freeze({ method: "GET", body: "" });
+function fetch(url, fetchOptions = {}) {
+  const options = { ...defaultOptions, ...fetchOptions };
+  const handler = url.startsWith("https") ? http : http;
+  return new Promise((resolve, reject) => {
+    const request = handler.request(url, options, (response) => {
+      processResponse(response, resolve);
+    });
+    request.on("error", (error) => reject(new Error(error.message)));
+    if (options == null ? void 0 : options.body) request.write(options.body);
+    request.end();
+  });
+}
+const processResponse = (response, onEnd) => {
+  const data = [];
+  response.on("data", (chunk) => data.push(chunk));
+  response.on("end", () => {
+    const bodyBuffer = Buffer.concat(data);
+    const result = {
+      ok: response.statusCode >= 200 && response.statusCode < 300,
+      status: response.statusCode,
+      statusText: response.statusMessage,
+      headers: new Map(Object.entries(response.headers)),
+      body: bodyBuffer,
+      arrayBuffer: () => Promise.resolve(bodyBuffer),
+      json: () => Promise.resolve(JSON.parse(bodyBuffer.toString()))
+    };
+    onEnd(result);
+  });
+};
+const DEFAULT_CONFIG = {
+  extension: ".lang",
+  // local or remote directory containing language files
+  location: "assets/lang/",
+  // list of available locales, handy for populating selector.
+  langs: ["en-US"],
+  locale: "en-US",
+  // init with user's preferred language
+  override: {}
+};
+class I18N {
+  /**
+   * Process options and start the module
+   * @param {Object} options
+   */
+  constructor(options = DEFAULT_CONFIG) {
+    this.langs = /* @__PURE__ */ Object.create(null);
+    this.loaded = [];
+    this.processConfig(options);
+  }
+  /**
+   * parse and format config
+   * @param {Object} options
+   */
+  processConfig(options) {
+    const { location, ...restOptions } = { ...DEFAULT_CONFIG, ...options };
+    const parsedLocation = location.replace(/\/?$/, "/");
+    this.config = { location: parsedLocation, ...restOptions };
+    const { override, preloaded = {} } = this.config;
+    const allLangs = Object.entries(this.langs).concat(Object.entries(override || preloaded));
+    this.langs = allLangs.reduce((acc, [locale, lang]) => {
+      acc[locale] = this.applyLanguage(locale, lang);
+      return acc;
+    }, {});
+    this.locale = this.config.locale || this.config.langs[0];
+  }
+  /**
+   * Load language and set default
+   * @param  {Object} options
+   * @return {Promise}        resolves language
+   */
+  init(options) {
+    this.processConfig({ ...this.config, ...options });
+    return this.setCurrent(this.locale);
+  }
+  /**
+   * Adds a language to the list of available languages
+   * @param {String} locale
+   * @param {String|Object} lang
+   */
+  addLanguage(locale, lang = {}) {
+    lang = typeof lang === "string" ? I18N.processFile(lang) : lang;
+    this.applyLanguage(locale, lang);
+    this.config.langs.push("locale");
+  }
+  /**
+   * get a string from a loaded language file
+   * @param  {String} key  - the key for the string we are trying to retrieve
+   * @param  {String} locale - locale to check for value
+   * @return {String} language string or undefined
+   */
+  getValue(key, locale = this.locale) {
+    var _a;
+    const value = (_a = this.langs[locale]) == null ? void 0 : _a[key];
+    return value || this.getFallbackValue(key);
+  }
+  /**
+   * Find a language that has desired key
+   * @param {String} key value key
+   * @return {String} found value or undefined
+   */
+  getFallbackValue(key) {
+    const fallbackLang = Object.values(this.langs).find((lang) => lang[key]);
+    return fallbackLang == null ? void 0 : fallbackLang[key];
+  }
+  /**
+   * Escape variable syntax
+   * @param  {String} str
+   * @return {String}     escaped str
+   */
+  makeSafe(str) {
+    const mapObj = {
+      "{": "\\{",
+      "}": "\\}",
+      "|": "\\|"
+    };
+    str = str.replace(/[{}|]/g, (matched) => mapObj[matched]);
+    return new RegExp(str, "g");
+  }
+  /**
+   * Temporarily put a string into the currently loaded language
+   * @param  {String} key
+   * @param  {String} string
+   * @return {String} string in current language
+   */
+  put(key, string) {
+    this.current[key] = string;
+    return string;
+  }
+  /**
+   * Parse arguments for the requested string
+   * @param  {String} key  the key we use to lookup our translation
+   * @param  {multi}  args  string, number or object containing our arguments
+   * @return {String}      updated string translation
+   */
+  get(key, args) {
+    const _this = this;
+    let value = this.getValue(key);
+    if (!value) {
+      return;
+    }
+    const tokens = value.match(/\{[^}]+?\}/g);
+    if (args && tokens) {
+      if ("object" === typeof args) {
+        for (const token of tokens) {
+          const key2 = token.substring(1, token.length - 1);
+          value = value.replace(_this.makeSafe(token), args[key2] || "");
+        }
+      } else {
+        value = value.replace(/\{[^}]+?\}/g, args);
+      }
+    }
+    return value;
+  }
+  /**
+   * Static method: Process a language file from raw text
+   * @param  {String} response
+   * @return {Object} processed language
+   */
+  static processFile(response) {
+    return I18N.fromFile(response.replace(/\n\n/g, "\n"));
+  }
+  /**
+   * Static method: Turn raw text from the language files into fancy JSON
+   * @param  {String} rawText
+   * @return {Object} converted language file
+   */
+  static fromFile(rawText) {
+    const lines = rawText.split("\n");
+    const lang = {};
+    for (let matches, i = 0; i < lines.length; i++) {
+      const regex = /^(.+?) *?= *?([^\n]+)/;
+      matches = regex.exec(lines[i]);
+      if (matches) {
+        lang[matches[1]] = matches[2].replace(/(^\s+|\s+$)/g, "");
+      }
+    }
+    return lang;
+  }
+  /**
+   * Load a remotely stored language file
+   * @param  {String} locale
+   * @param  {Boolean} useCache
+   * @return {Promise}       resolves response
+   */
+  loadLang(locale, useCache = true) {
+    const _this = this;
+    return new Promise(function(resolve, reject) {
+      if (_this.loaded.indexOf(locale) !== -1 && useCache) {
+        _this.applyLanguage(_this.langs[locale]);
+        return resolve(_this.langs[locale]);
+      } else {
+        const langFile = [_this.config.location, locale, _this.config.extension].join("");
+        return fetch(langFile).then(({ data: lang }) => {
+          const processedFile = _this.processFile(lang);
+          _this.applyLanguage(locale, processedFile);
+          _this.loaded.push(locale);
+          return resolve(_this.langs[locale]);
+        }).catch(() => {
+          const lang = _this.applyLanguage(locale);
+          resolve(lang);
+        });
+      }
+    });
+  }
+  /**
+   * applies overrides from config
+   * @param {String} locale
+   * @param {Object} lang
+   * @return {Object} overriden language
+   */
+  applyLanguage(locale, lang = {}) {
+    const override = this.config.override[locale] || {};
+    const existingLang = this.langs[locale] || {};
+    this.langs[locale] = { ...existingLang, ...lang, ...override };
+    return this.langs[locale];
+  }
+  /**
+   * return currently available languages
+   * @return {Object} all configured languages
+   */
+  get getLangs() {
+    return this.config.langs;
+  }
+  /**
+   * Attempt to set the current language to the local provided
+   * @param {String}   locale
+   * @return {Promise} language
+   */
+  async setCurrent(locale = "en-US") {
+    await this.loadLang(locale);
+    this.locale = locale;
+    this.current = this.langs[locale];
+    return this.current;
+  }
+}
+const mi18n = new I18N();
+export {
+  I18N,
+  mi18n as default
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"i18n.es.min.js","sources":["../__vite-browser-external","../src/fetch.js","../src/mi18n.js"],"sourcesContent":["export default {}","import https from 'https'\nimport http from 'http'\n\nconst defaultOptions = Object.freeze({ method: 'GET', body: '' })\n/**\n * Fetches a resource from the network.\n *\n * @param {string} url - The URL to fetch.\n * @param {Object} [fetchOptions={}] - The options for the fetch request.\n * @param {Object} [fetchOptions.headers] - Headers to include in the request.\n * @param {string} [fetchOptions.method] - The HTTP method to use (e.g., 'GET', 'POST').\n * @param {string|Buffer} [fetchOptions.body] - The body of the request.\n * @return {Promise<Object>} A promise that resolves to the response object.\n * @return {boolean} return.ok - Indicates if the response status is in the range 200-299.\n * @return {number} return.status - The HTTP status code of the response.\n * @return {string} return.statusText - The HTTP status message of the response.\n * @return {Map<string, string>} return.headers - The headers of the response.\n * @return {Buffer} return.body - The body of the response as a Buffer.\n * @return {function(): Promise<Buffer>} return.arrayBuffer - A function that returns a promise resolving to the body as an ArrayBuffer.\n * @return {function(): Promise<Object>} return.json - A function that returns a promise resolving to the body parsed as JSON.\n */\nexport function fetch(url, fetchOptions = {}) {\n  const options = { ...defaultOptions, ...fetchOptions }\n  const handler = url.startsWith('https') ? https : http\n\n  return new Promise((resolve, reject) => {\n    const request = handler.request(url, options, response => {\n      processResponse(response, resolve)\n    })\n\n    request.on('error', error => reject(new Error(error.message)))\n    if (options?.body) request.write(options.body)\n    request.end()\n  })\n}\n\nconst processResponse = (response, onEnd) => {\n  const data = []\n  response.on('data', chunk => data.push(chunk))\n  response.on('end', () => {\n    const bodyBuffer = Buffer.concat(data)\n    const result = {\n      ok: response.statusCode >= 200 && response.statusCode < 300,\n      status: response.statusCode,\n      statusText: response.statusMessage,\n      headers: new Map(Object.entries(response.headers)),\n      body: bodyBuffer,\n      arrayBuffer: () => Promise.resolve(bodyBuffer),\n      json: () => Promise.resolve(JSON.parse(bodyBuffer.toString())),\n    }\n    onEnd(result)\n  })\n}\n","import { fetch } from './fetch.js'\n\nconst DEFAULT_CONFIG = {\n  extension: '.lang',\n  // local or remote directory containing language files\n  location: 'assets/lang/',\n  // list of available locales, handy for populating selector.\n  langs: ['en-US'],\n  locale: 'en-US', // init with user's preferred language\n  override: {},\n}\n\n/**\n * Main i18n class\n * @class I18N\n * @classdesc methods and data store for i18n\n */\nexport class I18N {\n  /**\n   * Process options and start the module\n   * @param {Object} options\n   */\n  constructor(options = DEFAULT_CONFIG) {\n    this.langs = Object.create(null)\n    this.loaded = []\n    this.processConfig(options)\n  }\n\n  /**\n   * parse and format config\n   * @param {Object} options\n   */\n  processConfig(options) {\n    const { location, ...restOptions } = { ...DEFAULT_CONFIG, ...options }\n    const parsedLocation = location.replace(/\\/?$/, '/')\n    this.config = { location: parsedLocation, ...restOptions }\n    const { override, preloaded = {} } = this.config\n    const allLangs = Object.entries(this.langs).concat(Object.entries(override || preloaded))\n    this.langs = allLangs.reduce((acc, [locale, lang]) => {\n      acc[locale] = this.applyLanguage(locale, lang)\n      return acc\n    }, {})\n    this.locale = this.config.locale || this.config.langs[0]\n  }\n\n  /**\n   * Load language and set default\n   * @param  {Object} options\n   * @return {Promise}        resolves language\n   */\n  init(options) {\n    this.processConfig({ ...this.config, ...options })\n    return this.setCurrent(this.locale)\n  }\n\n  /**\n   * Adds a language to the list of available languages\n   * @param {String} locale\n   * @param {String|Object} lang\n   */\n  addLanguage(locale, lang = {}) {\n    lang = typeof lang === 'string' ? I18N.processFile(lang) : lang\n    this.applyLanguage(locale, lang)\n    this.config.langs.push('locale')\n  }\n\n  /**\n   * get a string from a loaded language file\n   * @param  {String} key  - the key for the string we are trying to retrieve\n   * @param  {String} locale - locale to check for value\n   * @return {String} language string or undefined\n   */\n  getValue(key, locale = this.locale) {\n    const value = this.langs[locale]?.[key]\n    return value || this.getFallbackValue(key)\n  }\n\n  /**\n   * Find a language that has desired key\n   * @param {String} key value key\n   * @return {String} found value or undefined\n   */\n  getFallbackValue(key) {\n    const fallbackLang = Object.values(this.langs).find(lang => lang[key])\n    return fallbackLang?.[key]\n  }\n\n  /**\n   * Escape variable syntax\n   * @param  {String} str\n   * @return {String}     escaped str\n   */\n  makeSafe(str) {\n    const mapObj = {\n      '{': '\\\\{',\n      '}': '\\\\}',\n      '|': '\\\\|',\n    }\n\n    str = str.replace(/[{}|]/g, matched => mapObj[matched])\n\n    return new RegExp(str, 'g')\n  }\n\n  /**\n   * Temporarily put a string into the currently loaded language\n   * @param  {String} key\n   * @param  {String} string\n   * @return {String} string in current language\n   */\n  put(key, string) {\n    this.current[key] = string\n\n    return string\n  }\n\n  /**\n   * Parse arguments for the requested string\n   * @param  {String} key  the key we use to lookup our translation\n   * @param  {multi}  args  string, number or object containing our arguments\n   * @return {String}      updated string translation\n   */\n  get(key, args) {\n    const _this = this\n    let value = this.getValue(key)\n    if (!value) {\n      return\n    }\n\n    const tokens = value.match(/\\{[^}]+?\\}/g)\n\n    if (args && tokens) {\n      if ('object' === typeof args) {\n        for (const token of tokens) {\n          const key = token.substring(1, token.length - 1)\n          value = value.replace(_this.makeSafe(token), args[key] || '')\n        }\n      } else {\n        value = value.replace(/\\{[^}]+?\\}/g, args)\n      }\n    }\n\n    return value\n  }\n\n  /**\n   * Static method: Process a language file from raw text\n   * @param  {String} response\n   * @return {Object} processed language\n   */\n  static processFile(response) {\n    return I18N.fromFile(response.replace(/\\n\\n/g, '\\n'))\n  }\n\n  /**\n   * Static method: Turn raw text from the language files into fancy JSON\n   * @param  {String} rawText\n   * @return {Object} converted language file\n   */\n  static fromFile(rawText) {\n    const lines = rawText.split('\\n')\n    const lang = {}\n\n    for (let matches, i = 0; i < lines.length; i++) {\n      const regex = /^(.+?) *?= *?([^\\n]+)/\n      matches = regex.exec(lines[i])\n      if (matches) {\n        lang[matches[1]] = matches[2].replace(/(^\\s+|\\s+$)/g, '')\n      }\n    }\n\n    return lang\n  }\n\n  /**\n   * Load a remotely stored language file\n   * @param  {String} locale\n   * @param  {Boolean} useCache\n   * @return {Promise}       resolves response\n   */\n  loadLang(locale, useCache = true) {\n    const _this = this\n    return new Promise(function (resolve, reject) {\n      if (_this.loaded.indexOf(locale) !== -1 && useCache) {\n        _this.applyLanguage(_this.langs[locale])\n        return resolve(_this.langs[locale])\n      } else {\n        const langFile = [_this.config.location, locale, _this.config.extension].join('')\n        return fetch(langFile)\n          .then(({ data: lang }) => {\n            const processedFile = _this.processFile(lang)\n            _this.applyLanguage(locale, processedFile)\n            _this.loaded.push(locale)\n            return resolve(_this.langs[locale])\n          })\n          .catch(() => {\n            const lang = _this.applyLanguage(locale)\n            resolve(lang)\n          })\n      }\n    })\n  }\n\n  /**\n   * applies overrides from config\n   * @param {String} locale\n   * @param {Object} lang\n   * @return {Object} overriden language\n   */\n  applyLanguage(locale, lang = {}) {\n    const override = this.config.override[locale] || {}\n    const existingLang = this.langs[locale] || {}\n    this.langs[locale] = { ...existingLang, ...lang, ...override }\n    return this.langs[locale]\n  }\n\n  /**\n   * return currently available languages\n   * @return {Object} all configured languages\n   */\n  get getLangs() {\n    return this.config.langs\n  }\n\n  /**\n   * Attempt to set the current language to the local provided\n   * @param {String}   locale\n   * @return {Promise} language\n   */\n  async setCurrent(locale = 'en-US') {\n    await this.loadLang(locale)\n    this.locale = locale\n    this.current = this.langs[locale]\n\n    return this.current\n  }\n}\n\nexport default new I18N()\n"],"names":["https","key"],"mappings":"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"}

package/dist/i18n.iife.min.js

@@ -0,0 +1,9 @@
+
+/**
+@draggable/i18n - https://github.com/Draggable/i18n
+Version: 1.0.3
+Author: Draggable https://draggable.io
+*/
+
+var i18n=function(e){"use strict";const t={},s=Object.freeze({method:"GET",body:""});const n=(e,t)=>{const s=[];e.on("data",(e=>s.push(e))),e.on("end",(()=>{const n=Buffer.concat(s),a={ok:e.statusCode>=200&&e.statusCode<300,status:e.statusCode,statusText:e.statusMessage,headers:new Map(Object.entries(e.headers)),body:n,arrayBuffer:()=>Promise.resolve(n),json:()=>Promise.resolve(JSON.parse(n.toString()))};t(a)}))},a={extension:".lang",location:"assets/lang/",langs:["en-US"],locale:"en-US",override:{}};class o{constructor(e=a){this.langs=Object.create(null),this.loaded=[],this.processConfig(e)}processConfig(e){const{location:t,...s}={...a,...e},n=t.replace(/\/?$/,"/");this.config={location:n,...s};const{override:o,preloaded:r={}}=this.config,i=Object.entries(this.langs).concat(Object.entries(o||r));this.langs=i.reduce(((e,[t,s])=>(e[t]=this.applyLanguage(t,s),e)),{}),this.locale=this.config.locale||this.config.langs[0]}init(e){return this.processConfig({...this.config,...e}),this.setCurrent(this.locale)}addLanguage(e,t={}){t="string"==typeof t?o.processFile(t):t,this.applyLanguage(e,t),this.config.langs.push("locale")}getValue(e,t=this.locale){var s;return(null==(s=this.langs[t])?void 0:s[e])||this.getFallbackValue(e)}getFallbackValue(e){const t=Object.values(this.langs).find((t=>t[e]));return null==t?void 0:t[e]}makeSafe(e){const t={"{":"\\{","}":"\\}","|":"\\|"};return e=e.replace(/[{}|]/g,(e=>t[e])),new RegExp(e,"g")}put(e,t){return this.current[e]=t,t}get(e,t){const s=this;let n=this.getValue(e);if(!n)return;const a=n.match(/\{[^}]+?\}/g);if(t&&a)if("object"==typeof t)for(const o of a){const e=o.substring(1,o.length-1);n=n.replace(s.makeSafe(o),t[e]||"")}else n=n.replace(/\{[^}]+?\}/g,t);return n}static processFile(e){return o.fromFile(e.replace(/\n\n/g,"\n"))}static fromFile(e){const t=e.split("\n"),s={};for(let n,a=0;a<t.length;a++){n=/^(.+?) *?= *?([^\n]+)/.exec(t[a]),n&&(s[n[1]]=n[2].replace(/(^\s+|\s+$)/g,""))}return s}loadLang(e,a=!0){const o=this;return new Promise((function(r,i){if(-1!==o.loaded.indexOf(e)&&a)return o.applyLanguage(o.langs[e]),r(o.langs[e]);return function(e,a={}){const o={...s,...a},r=(e.startsWith("https"),t);return new Promise(((t,s)=>{const a=r.request(e,o,(e=>{n(e,t)}));a.on("error",(e=>s(new Error(e.message)))),(null==o?void 0:o.body)&&a.write(o.body),a.end()}))}([o.config.location,e,o.config.extension].join("")).then((({data:t})=>{const s=o.processFile(t);return o.applyLanguage(e,s),o.loaded.push(e),r(o.langs[e])})).catch((()=>{const t=o.applyLanguage(e);r(t)}))}))}applyLanguage(e,t={}){const s=this.config.override[e]||{},n=this.langs[e]||{};return this.langs[e]={...n,...t,...s},this.langs[e]}get getLangs(){return this.config.langs}async setCurrent(e="en-US"){return await this.loadLang(e),this.locale=e,this.current=this.langs[e],this.current}}const r=new o;return e.I18N=o,e.default=r,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}}),e}({});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"i18n.iife.min.js","sources":["../__vite-browser-external","../src/fetch.js","../src/mi18n.js"],"sourcesContent":["export default {}","import https from 'https'\nimport http from 'http'\n\nconst defaultOptions = Object.freeze({ method: 'GET', body: '' })\n/**\n * Fetches a resource from the network.\n *\n * @param {string} url - The URL to fetch.\n * @param {Object} [fetchOptions={}] - The options for the fetch request.\n * @param {Object} [fetchOptions.headers] - Headers to include in the request.\n * @param {string} [fetchOptions.method] - The HTTP method to use (e.g., 'GET', 'POST').\n * @param {string|Buffer} [fetchOptions.body] - The body of the request.\n * @return {Promise<Object>} A promise that resolves to the response object.\n * @return {boolean} return.ok - Indicates if the response status is in the range 200-299.\n * @return {number} return.status - The HTTP status code of the response.\n * @return {string} return.statusText - The HTTP status message of the response.\n * @return {Map<string, string>} return.headers - The headers of the response.\n * @return {Buffer} return.body - The body of the response as a Buffer.\n * @return {function(): Promise<Buffer>} return.arrayBuffer - A function that returns a promise resolving to the body as an ArrayBuffer.\n * @return {function(): Promise<Object>} return.json - A function that returns a promise resolving to the body parsed as JSON.\n */\nexport function fetch(url, fetchOptions = {}) {\n  const options = { ...defaultOptions, ...fetchOptions }\n  const handler = url.startsWith('https') ? https : http\n\n  return new Promise((resolve, reject) => {\n    const request = handler.request(url, options, response => {\n      processResponse(response, resolve)\n    })\n\n    request.on('error', error => reject(new Error(error.message)))\n    if (options?.body) request.write(options.body)\n    request.end()\n  })\n}\n\nconst processResponse = (response, onEnd) => {\n  const data = []\n  response.on('data', chunk => data.push(chunk))\n  response.on('end', () => {\n    const bodyBuffer = Buffer.concat(data)\n    const result = {\n      ok: response.statusCode >= 200 && response.statusCode < 300,\n      status: response.statusCode,\n      statusText: response.statusMessage,\n      headers: new Map(Object.entries(response.headers)),\n      body: bodyBuffer,\n      arrayBuffer: () => Promise.resolve(bodyBuffer),\n      json: () => Promise.resolve(JSON.parse(bodyBuffer.toString())),\n    }\n    onEnd(result)\n  })\n}\n","import { fetch } from './fetch.js'\n\nconst DEFAULT_CONFIG = {\n  extension: '.lang',\n  // local or remote directory containing language files\n  location: 'assets/lang/',\n  // list of available locales, handy for populating selector.\n  langs: ['en-US'],\n  locale: 'en-US', // init with user's preferred language\n  override: {},\n}\n\n/**\n * Main i18n class\n * @class I18N\n * @classdesc methods and data store for i18n\n */\nexport class I18N {\n  /**\n   * Process options and start the module\n   * @param {Object} options\n   */\n  constructor(options = DEFAULT_CONFIG) {\n    this.langs = Object.create(null)\n    this.loaded = []\n    this.processConfig(options)\n  }\n\n  /**\n   * parse and format config\n   * @param {Object} options\n   */\n  processConfig(options) {\n    const { location, ...restOptions } = { ...DEFAULT_CONFIG, ...options }\n    const parsedLocation = location.replace(/\\/?$/, '/')\n    this.config = { location: parsedLocation, ...restOptions }\n    const { override, preloaded = {} } = this.config\n    const allLangs = Object.entries(this.langs).concat(Object.entries(override || preloaded))\n    this.langs = allLangs.reduce((acc, [locale, lang]) => {\n      acc[locale] = this.applyLanguage(locale, lang)\n      return acc\n    }, {})\n    this.locale = this.config.locale || this.config.langs[0]\n  }\n\n  /**\n   * Load language and set default\n   * @param  {Object} options\n   * @return {Promise}        resolves language\n   */\n  init(options) {\n    this.processConfig({ ...this.config, ...options })\n    return this.setCurrent(this.locale)\n  }\n\n  /**\n   * Adds a language to the list of available languages\n   * @param {String} locale\n   * @param {String|Object} lang\n   */\n  addLanguage(locale, lang = {}) {\n    lang = typeof lang === 'string' ? I18N.processFile(lang) : lang\n    this.applyLanguage(locale, lang)\n    this.config.langs.push('locale')\n  }\n\n  /**\n   * get a string from a loaded language file\n   * @param  {String} key  - the key for the string we are trying to retrieve\n   * @param  {String} locale - locale to check for value\n   * @return {String} language string or undefined\n   */\n  getValue(key, locale = this.locale) {\n    const value = this.langs[locale]?.[key]\n    return value || this.getFallbackValue(key)\n  }\n\n  /**\n   * Find a language that has desired key\n   * @param {String} key value key\n   * @return {String} found value or undefined\n   */\n  getFallbackValue(key) {\n    const fallbackLang = Object.values(this.langs).find(lang => lang[key])\n    return fallbackLang?.[key]\n  }\n\n  /**\n   * Escape variable syntax\n   * @param  {String} str\n   * @return {String}     escaped str\n   */\n  makeSafe(str) {\n    const mapObj = {\n      '{': '\\\\{',\n      '}': '\\\\}',\n      '|': '\\\\|',\n    }\n\n    str = str.replace(/[{}|]/g, matched => mapObj[matched])\n\n    return new RegExp(str, 'g')\n  }\n\n  /**\n   * Temporarily put a string into the currently loaded language\n   * @param  {String} key\n   * @param  {String} string\n   * @return {String} string in current language\n   */\n  put(key, string) {\n    this.current[key] = string\n\n    return string\n  }\n\n  /**\n   * Parse arguments for the requested string\n   * @param  {String} key  the key we use to lookup our translation\n   * @param  {multi}  args  string, number or object containing our arguments\n   * @return {String}      updated string translation\n   */\n  get(key, args) {\n    const _this = this\n    let value = this.getValue(key)\n    if (!value) {\n      return\n    }\n\n    const tokens = value.match(/\\{[^}]+?\\}/g)\n\n    if (args && tokens) {\n      if ('object' === typeof args) {\n        for (const token of tokens) {\n          const key = token.substring(1, token.length - 1)\n          value = value.replace(_this.makeSafe(token), args[key] || '')\n        }\n      } else {\n        value = value.replace(/\\{[^}]+?\\}/g, args)\n      }\n    }\n\n    return value\n  }\n\n  /**\n   * Static method: Process a language file from raw text\n   * @param  {String} response\n   * @return {Object} processed language\n   */\n  static processFile(response) {\n    return I18N.fromFile(response.replace(/\\n\\n/g, '\\n'))\n  }\n\n  /**\n   * Static method: Turn raw text from the language files into fancy JSON\n   * @param  {String} rawText\n   * @return {Object} converted language file\n   */\n  static fromFile(rawText) {\n    const lines = rawText.split('\\n')\n    const lang = {}\n\n    for (let matches, i = 0; i < lines.length; i++) {\n      const regex = /^(.+?) *?= *?([^\\n]+)/\n      matches = regex.exec(lines[i])\n      if (matches) {\n        lang[matches[1]] = matches[2].replace(/(^\\s+|\\s+$)/g, '')\n      }\n    }\n\n    return lang\n  }\n\n  /**\n   * Load a remotely stored language file\n   * @param  {String} locale\n   * @param  {Boolean} useCache\n   * @return {Promise}       resolves response\n   */\n  loadLang(locale, useCache = true) {\n    const _this = this\n    return new Promise(function (resolve, reject) {\n      if (_this.loaded.indexOf(locale) !== -1 && useCache) {\n        _this.applyLanguage(_this.langs[locale])\n        return resolve(_this.langs[locale])\n      } else {\n        const langFile = [_this.config.location, locale, _this.config.extension].join('')\n        return fetch(langFile)\n          .then(({ data: lang }) => {\n            const processedFile = _this.processFile(lang)\n            _this.applyLanguage(locale, processedFile)\n            _this.loaded.push(locale)\n            return resolve(_this.langs[locale])\n          })\n          .catch(() => {\n            const lang = _this.applyLanguage(locale)\n            resolve(lang)\n          })\n      }\n    })\n  }\n\n  /**\n   * applies overrides from config\n   * @param {String} locale\n   * @param {Object} lang\n   * @return {Object} overriden language\n   */\n  applyLanguage(locale, lang = {}) {\n    const override = this.config.override[locale] || {}\n    const existingLang = this.langs[locale] || {}\n    this.langs[locale] = { ...existingLang, ...lang, ...override }\n    return this.langs[locale]\n  }\n\n  /**\n   * return currently available languages\n   * @return {Object} all configured languages\n   */\n  get getLangs() {\n    return this.config.langs\n  }\n\n  /**\n   * Attempt to set the current language to the local provided\n   * @param {String}   locale\n   * @return {Promise} language\n   */\n  async setCurrent(locale = 'en-US') {\n    await this.loadLang(locale)\n    this.locale = locale\n    this.current = this.langs[locale]\n\n    return this.current\n  }\n}\n\nexport default new I18N()\n"],"names":["http","defaultOptions","Object","freeze","method","body","processResponse","response","onEnd","data","on","chunk","push","bodyBuffer","Buffer","concat","result","ok","statusCode","status","statusText","statusMessage","headers","Map","entries","arrayBuffer","Promise","resolve","json","JSON","parse","toString","DEFAULT_CONFIG","extension","location","langs","locale","override","I18N","constructor","options","this","create","loaded","processConfig","restOptions","parsedLocation","replace","config","preloaded","allLangs","reduce","acc","lang","applyLanguage","init","setCurrent","addLanguage","processFile","getValue","key","_a","getFallbackValue","fallbackLang","values","find","makeSafe","str","mapObj","matched","RegExp","put","string","current","get","args","_this","value","tokens","match","token","substring","length","fromFile","rawText","lines","split","matches","i","exec","loadLang","useCache","reject","indexOf","url","fetchOptions","handler","startsWith","https","request","error","Error","message","write","end","fetch","join","then","processedFile","catch","existingLang","getLangs","mi18n"],"mappings":"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"}

package/dist/i18n.umd.min.js

@@ -0,0 +1,9 @@
+
+/**
+@draggable/i18n - https://github.com/Draggable/i18n
+Version: 1.0.3
+Author: Draggable https://draggable.io
+*/
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).i18n={})}(this,(function(e){"use strict";const t={},n=Object.freeze({method:"GET",body:""});const s=(e,t)=>{const n=[];e.on("data",(e=>n.push(e))),e.on("end",(()=>{const s=Buffer.concat(n),o={ok:e.statusCode>=200&&e.statusCode<300,status:e.statusCode,statusText:e.statusMessage,headers:new Map(Object.entries(e.headers)),body:s,arrayBuffer:()=>Promise.resolve(s),json:()=>Promise.resolve(JSON.parse(s.toString()))};t(o)}))},o={extension:".lang",location:"assets/lang/",langs:["en-US"],locale:"en-US",override:{}};class a{constructor(e=o){this.langs=Object.create(null),this.loaded=[],this.processConfig(e)}processConfig(e){const{location:t,...n}={...o,...e},s=t.replace(/\/?$/,"/");this.config={location:s,...n};const{override:a,preloaded:i={}}=this.config,r=Object.entries(this.langs).concat(Object.entries(a||i));this.langs=r.reduce(((e,[t,n])=>(e[t]=this.applyLanguage(t,n),e)),{}),this.locale=this.config.locale||this.config.langs[0]}init(e){return this.processConfig({...this.config,...e}),this.setCurrent(this.locale)}addLanguage(e,t={}){t="string"==typeof t?a.processFile(t):t,this.applyLanguage(e,t),this.config.langs.push("locale")}getValue(e,t=this.locale){var n;return(null==(n=this.langs[t])?void 0:n[e])||this.getFallbackValue(e)}getFallbackValue(e){const t=Object.values(this.langs).find((t=>t[e]));return null==t?void 0:t[e]}makeSafe(e){const t={"{":"\\{","}":"\\}","|":"\\|"};return e=e.replace(/[{}|]/g,(e=>t[e])),new RegExp(e,"g")}put(e,t){return this.current[e]=t,t}get(e,t){const n=this;let s=this.getValue(e);if(!s)return;const o=s.match(/\{[^}]+?\}/g);if(t&&o)if("object"==typeof t)for(const a of o){const e=a.substring(1,a.length-1);s=s.replace(n.makeSafe(a),t[e]||"")}else s=s.replace(/\{[^}]+?\}/g,t);return s}static processFile(e){return a.fromFile(e.replace(/\n\n/g,"\n"))}static fromFile(e){const t=e.split("\n"),n={};for(let s,o=0;o<t.length;o++){s=/^(.+?) *?= *?([^\n]+)/.exec(t[o]),s&&(n[s[1]]=s[2].replace(/(^\s+|\s+$)/g,""))}return n}loadLang(e,o=!0){const a=this;return new Promise((function(i,r){if(-1!==a.loaded.indexOf(e)&&o)return a.applyLanguage(a.langs[e]),i(a.langs[e]);return function(e,o={}){const a={...n,...o},i=(e.startsWith("https"),t);return new Promise(((t,n)=>{const o=i.request(e,a,(e=>{s(e,t)}));o.on("error",(e=>n(new Error(e.message)))),(null==a?void 0:a.body)&&o.write(a.body),o.end()}))}([a.config.location,e,a.config.extension].join("")).then((({data:t})=>{const n=a.processFile(t);return a.applyLanguage(e,n),a.loaded.push(e),i(a.langs[e])})).catch((()=>{const t=a.applyLanguage(e);i(t)}))}))}applyLanguage(e,t={}){const n=this.config.override[e]||{},s=this.langs[e]||{};return this.langs[e]={...s,...t,...n},this.langs[e]}get getLangs(){return this.config.langs}async setCurrent(e="en-US"){return await this.loadLang(e),this.locale=e,this.current=this.langs[e],this.current}}const i=new a;e.I18N=a,e.default=i,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"i18n.umd.min.js","sources":["../__vite-browser-external","../src/fetch.js","../src/mi18n.js"],"sourcesContent":["export default {}","import https from 'https'\nimport http from 'http'\n\nconst defaultOptions = Object.freeze({ method: 'GET', body: '' })\n/**\n * Fetches a resource from the network.\n *\n * @param {string} url - The URL to fetch.\n * @param {Object} [fetchOptions={}] - The options for the fetch request.\n * @param {Object} [fetchOptions.headers] - Headers to include in the request.\n * @param {string} [fetchOptions.method] - The HTTP method to use (e.g., 'GET', 'POST').\n * @param {string|Buffer} [fetchOptions.body] - The body of the request.\n * @return {Promise<Object>} A promise that resolves to the response object.\n * @return {boolean} return.ok - Indicates if the response status is in the range 200-299.\n * @return {number} return.status - The HTTP status code of the response.\n * @return {string} return.statusText - The HTTP status message of the response.\n * @return {Map<string, string>} return.headers - The headers of the response.\n * @return {Buffer} return.body - The body of the response as a Buffer.\n * @return {function(): Promise<Buffer>} return.arrayBuffer - A function that returns a promise resolving to the body as an ArrayBuffer.\n * @return {function(): Promise<Object>} return.json - A function that returns a promise resolving to the body parsed as JSON.\n */\nexport function fetch(url, fetchOptions = {}) {\n  const options = { ...defaultOptions, ...fetchOptions }\n  const handler = url.startsWith('https') ? https : http\n\n  return new Promise((resolve, reject) => {\n    const request = handler.request(url, options, response => {\n      processResponse(response, resolve)\n    })\n\n    request.on('error', error => reject(new Error(error.message)))\n    if (options?.body) request.write(options.body)\n    request.end()\n  })\n}\n\nconst processResponse = (response, onEnd) => {\n  const data = []\n  response.on('data', chunk => data.push(chunk))\n  response.on('end', () => {\n    const bodyBuffer = Buffer.concat(data)\n    const result = {\n      ok: response.statusCode >= 200 && response.statusCode < 300,\n      status: response.statusCode,\n      statusText: response.statusMessage,\n      headers: new Map(Object.entries(response.headers)),\n      body: bodyBuffer,\n      arrayBuffer: () => Promise.resolve(bodyBuffer),\n      json: () => Promise.resolve(JSON.parse(bodyBuffer.toString())),\n    }\n    onEnd(result)\n  })\n}\n","import { fetch } from './fetch.js'\n\nconst DEFAULT_CONFIG = {\n  extension: '.lang',\n  // local or remote directory containing language files\n  location: 'assets/lang/',\n  // list of available locales, handy for populating selector.\n  langs: ['en-US'],\n  locale: 'en-US', // init with user's preferred language\n  override: {},\n}\n\n/**\n * Main i18n class\n * @class I18N\n * @classdesc methods and data store for i18n\n */\nexport class I18N {\n  /**\n   * Process options and start the module\n   * @param {Object} options\n   */\n  constructor(options = DEFAULT_CONFIG) {\n    this.langs = Object.create(null)\n    this.loaded = []\n    this.processConfig(options)\n  }\n\n  /**\n   * parse and format config\n   * @param {Object} options\n   */\n  processConfig(options) {\n    const { location, ...restOptions } = { ...DEFAULT_CONFIG, ...options }\n    const parsedLocation = location.replace(/\\/?$/, '/')\n    this.config = { location: parsedLocation, ...restOptions }\n    const { override, preloaded = {} } = this.config\n    const allLangs = Object.entries(this.langs).concat(Object.entries(override || preloaded))\n    this.langs = allLangs.reduce((acc, [locale, lang]) => {\n      acc[locale] = this.applyLanguage(locale, lang)\n      return acc\n    }, {})\n    this.locale = this.config.locale || this.config.langs[0]\n  }\n\n  /**\n   * Load language and set default\n   * @param  {Object} options\n   * @return {Promise}        resolves language\n   */\n  init(options) {\n    this.processConfig({ ...this.config, ...options })\n    return this.setCurrent(this.locale)\n  }\n\n  /**\n   * Adds a language to the list of available languages\n   * @param {String} locale\n   * @param {String|Object} lang\n   */\n  addLanguage(locale, lang = {}) {\n    lang = typeof lang === 'string' ? I18N.processFile(lang) : lang\n    this.applyLanguage(locale, lang)\n    this.config.langs.push('locale')\n  }\n\n  /**\n   * get a string from a loaded language file\n   * @param  {String} key  - the key for the string we are trying to retrieve\n   * @param  {String} locale - locale to check for value\n   * @return {String} language string or undefined\n   */\n  getValue(key, locale = this.locale) {\n    const value = this.langs[locale]?.[key]\n    return value || this.getFallbackValue(key)\n  }\n\n  /**\n   * Find a language that has desired key\n   * @param {String} key value key\n   * @return {String} found value or undefined\n   */\n  getFallbackValue(key) {\n    const fallbackLang = Object.values(this.langs).find(lang => lang[key])\n    return fallbackLang?.[key]\n  }\n\n  /**\n   * Escape variable syntax\n   * @param  {String} str\n   * @return {String}     escaped str\n   */\n  makeSafe(str) {\n    const mapObj = {\n      '{': '\\\\{',\n      '}': '\\\\}',\n      '|': '\\\\|',\n    }\n\n    str = str.replace(/[{}|]/g, matched => mapObj[matched])\n\n    return new RegExp(str, 'g')\n  }\n\n  /**\n   * Temporarily put a string into the currently loaded language\n   * @param  {String} key\n   * @param  {String} string\n   * @return {String} string in current language\n   */\n  put(key, string) {\n    this.current[key] = string\n\n    return string\n  }\n\n  /**\n   * Parse arguments for the requested string\n   * @param  {String} key  the key we use to lookup our translation\n   * @param  {multi}  args  string, number or object containing our arguments\n   * @return {String}      updated string translation\n   */\n  get(key, args) {\n    const _this = this\n    let value = this.getValue(key)\n    if (!value) {\n      return\n    }\n\n    const tokens = value.match(/\\{[^}]+?\\}/g)\n\n    if (args && tokens) {\n      if ('object' === typeof args) {\n        for (const token of tokens) {\n          const key = token.substring(1, token.length - 1)\n          value = value.replace(_this.makeSafe(token), args[key] || '')\n        }\n      } else {\n        value = value.replace(/\\{[^}]+?\\}/g, args)\n      }\n    }\n\n    return value\n  }\n\n  /**\n   * Static method: Process a language file from raw text\n   * @param  {String} response\n   * @return {Object} processed language\n   */\n  static processFile(response) {\n    return I18N.fromFile(response.replace(/\\n\\n/g, '\\n'))\n  }\n\n  /**\n   * Static method: Turn raw text from the language files into fancy JSON\n   * @param  {String} rawText\n   * @return {Object} converted language file\n   */\n  static fromFile(rawText) {\n    const lines = rawText.split('\\n')\n    const lang = {}\n\n    for (let matches, i = 0; i < lines.length; i++) {\n      const regex = /^(.+?) *?= *?([^\\n]+)/\n      matches = regex.exec(lines[i])\n      if (matches) {\n        lang[matches[1]] = matches[2].replace(/(^\\s+|\\s+$)/g, '')\n      }\n    }\n\n    return lang\n  }\n\n  /**\n   * Load a remotely stored language file\n   * @param  {String} locale\n   * @param  {Boolean} useCache\n   * @return {Promise}       resolves response\n   */\n  loadLang(locale, useCache = true) {\n    const _this = this\n    return new Promise(function (resolve, reject) {\n      if (_this.loaded.indexOf(locale) !== -1 && useCache) {\n        _this.applyLanguage(_this.langs[locale])\n        return resolve(_this.langs[locale])\n      } else {\n        const langFile = [_this.config.location, locale, _this.config.extension].join('')\n        return fetch(langFile)\n          .then(({ data: lang }) => {\n            const processedFile = _this.processFile(lang)\n            _this.applyLanguage(locale, processedFile)\n            _this.loaded.push(locale)\n            return resolve(_this.langs[locale])\n          })\n          .catch(() => {\n            const lang = _this.applyLanguage(locale)\n            resolve(lang)\n          })\n      }\n    })\n  }\n\n  /**\n   * applies overrides from config\n   * @param {String} locale\n   * @param {Object} lang\n   * @return {Object} overriden language\n   */\n  applyLanguage(locale, lang = {}) {\n    const override = this.config.override[locale] || {}\n    const existingLang = this.langs[locale] || {}\n    this.langs[locale] = { ...existingLang, ...lang, ...override }\n    return this.langs[locale]\n  }\n\n  /**\n   * return currently available languages\n   * @return {Object} all configured languages\n   */\n  get getLangs() {\n    return this.config.langs\n  }\n\n  /**\n   * Attempt to set the current language to the local provided\n   * @param {String}   locale\n   * @return {Promise} language\n   */\n  async setCurrent(locale = 'en-US') {\n    await this.loadLang(locale)\n    this.locale = locale\n    this.current = this.langs[locale]\n\n    return this.current\n  }\n}\n\nexport default new I18N()\n"],"names":["http","defaultOptions","Object","freeze","method","body","processResponse","response","onEnd","data","on","chunk","push","bodyBuffer","Buffer","concat","result","ok","statusCode","status","statusText","statusMessage","headers","Map","entries","arrayBuffer","Promise","resolve","json","JSON","parse","toString","DEFAULT_CONFIG","extension","location","langs","locale","override","I18N","constructor","options","this","create","loaded","processConfig","restOptions","parsedLocation","replace","config","preloaded","allLangs","reduce","acc","lang","applyLanguage","init","setCurrent","addLanguage","processFile","getValue","key","_a","getFallbackValue","fallbackLang","values","find","makeSafe","str","mapObj","matched","RegExp","put","string","current","get","args","_this","value","tokens","match","token","substring","length","fromFile","rawText","lines","split","matches","i","exec","loadLang","useCache","reject","indexOf","url","fetchOptions","handler","startsWith","https","request","error","Error","message","write","end","fetch","join","then","processedFile","catch","existingLang","getLangs","mi18n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@draggable/i18n",
+  "version": "1.0.4",
+  "description": "A simple yet robust i18n solution for universal JavaScript apps.",
+  "main": "dist/i18n.es.min.js",
+  "type": "module",
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test src/**/*.test.js",
+    "test:watch": "yarn test -- --reporter min --watch",
+    "lint": "eslint ./src --ext .js || true",
+    "start": "webpack-dev-server --mode development",
+    "semantic-release": "semantic-release",
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "repository": {
+    "url": "https://github.com/Draggable/i18n",
+    "type": "git"
+  },
+  "keywords": [
+    "i18n"
+  ],
+  "author": "Draggable https://draggable.io",
+  "contributors": [
+    {
+      "name": "Kevin Chappell",
+      "email": "kevin@chappell.dev",
+      "url": "https://kevin-chappell.com"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Draggable/i18n/issues"
+  },
+  "homepage": "https://github.com/Draggable/i18n",
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@commitlint/cli": "^19.5.0",
+    "@commitlint/config-conventional": "^19.5.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^12.0.1",
+    "lefthook": "^1.7.22",
+    "lint-staged": "^15.2.10",
+    "semantic-release": "^24.1.3",
+    "vite": "^5.4.9",
+    "vite-plugin-banner": "^0.8.0",
+    "vite-plugin-compression": "^0.5.1"
+  },
+  "lint-staged": {
+    "src/**/*.js": [
+      "biome lint",
+      "biome format",
+      "git add"
+    ]
+  },
+  "release": {
+    "branch": "master",
+    "verifyConditions": [
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/git"
+    ],
+    "prepare": [
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/git"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ],
+    "rules": {
+      "type-enum": [
+        2,
+        "always",
+        [
+          "build",
+          "chore",
+          "ci",
+          "docs",
+          "feat",
+          "fix",
+          "perf",
+          "refactor",
+          "revert",
+          "style",
+          "test"
+        ]
+      ]
+    }
+  }
+}