@wener/utils 1.1.50 → 1.1.53

package/lib/i18n/createTranslate.test.js

@@ -0,0 +1,177 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { assert, test } from "vitest";
+import { createTranslate } from "./createTranslate.js";
+test("exports", function () {
+    assert.equal(typeof createTranslate === "undefined" ? "undefined" : _type_of(createTranslate), "function", "exports a function");
+    var out = createTranslate();
+    assert.equal(typeof out === "undefined" ? "undefined" : _type_of(out), "object", "returns an object");
+    assert.equal(_type_of(out.t), "function", "~> has \"t\" function");
+    assert.equal(_type_of(out.dict), "function", "~> has \"dict\" function");
+    assert.equal(_type_of(out.locale), "function", "~> has \"locale\" function");
+});
+test("usage", function () {
+    var ctx = createTranslate({
+        en: {
+            hello: "Hello, {{name}}!"
+        },
+        es: {
+            hello: "Hola {{name}}!"
+        },
+        pt: {
+            foo: "foo {{name}}~!"
+        }
+    });
+    assert.deepEqual(ctx.dict("en"), {
+        hello: "Hello, {{name}}!"
+    });
+    assert.equal(ctx.dict("foobar"), undefined);
+    var foo = ctx.t("hello");
+    assert.equal(foo, "", "~> \"\" w/o locale");
+    assert.equal(ctx.locale("en"), "en", ">>> ctx.locale()");
+    assert.equal(ctx.locale(), "en");
+    var bar = ctx.t("hello");
+    assert.notEqual(bar, "", "(en) found \"hello\" key");
+    assert.equal(bar, "Hello, !", "~> interpolations empty if missing param");
+    var baz = ctx.t("hello", {
+        name: "world"
+    });
+    assert.equal(baz, "Hello, world!", "~> interpolations successful");
+    var bat = ctx.t("hello", {
+        name: "world"
+    }, "es");
+    assert.notEqual(bat, "", "(es) found \"hello\" key");
+    assert.equal(bat, "Hola world!", "~> success");
+    assert.equal(ctx.t("hello", {
+        name: "world"
+    }, "pt"), "", "(pt) did NOT find \"hello\" key");
+    assert.equal(ctx.dict("pt", {
+        hello: "O\u00ED {{name}}!"
+    }), undefined, ">>> ctx.set()");
+    var quz = ctx.t("hello", {
+        name: "world"
+    }, "pt");
+    assert.notEqual(quz, "", "(pt) found \"hello\" key");
+    assert.equal(quz, "O\u00ED world!", "~> success");
+    var qut = ctx.t("foo", {
+        name: "bar"
+    }, "pt");
+    assert.notEqual(qut, "", "(pt) found \"foo\" key");
+    assert.equal(qut, "foo bar~!", "~> success");
+    assert.equal(ctx.locale("es"), "es", ">>> ctx.locale()");
+    assert.equal(ctx.locale(), "es");
+    assert.equal(ctx.locale(""), "es");
+    assert.equal(ctx.locale(false), "es");
+    assert.equal(ctx.locale(null), "es");
+    assert.equal(ctx.locale(0), "es");
+    var qux = ctx.t("hello", {
+        name: "default"
+    });
+    assert.notEqual(qux, "", "(es) found \"hello\" key");
+    assert.equal(qux, "Hola default!", "~> success");
+    assert.equal(ctx.t("hello", {
+        name: "world"
+    }, "de"), "", "(de) did NOT find \"hello\" key");
+    assert.equal(ctx.dict("de", {
+        hello: "Hallo {{name}}!"
+    }), undefined, ">>> ctx.set(de)");
+    var qar = ctx.t("hello", {
+        name: "world"
+    }, "de");
+    assert.notEqual(qar, "", "(de) found \"hello\" key");
+    assert.equal(qar, "Hallo world!", "~> success");
+});
+test("functional", function () {
+    var ctx = createTranslate({
+        en: {
+            hello: function hello(value) {
+                return "hello ".concat(value || "stranger", "~!");
+            }
+        }
+    });
+    ctx.locale("en");
+    var foo = ctx.t("hello");
+    assert.equal(foo, "hello stranger~!", "~> called function w/o param");
+    var bar = ctx.t("hello", "world");
+    assert.equal(bar, "hello world~!", "~> called function w/ param (string)");
+    var baz = ctx.t("hello", [
+        1,
+        2,
+        3
+    ]);
+    assert.equal(baz, "hello 1,2,3~!", "~> called function w/ param (array)");
+});
+test("nested", function () {
+    var ctx = createTranslate({
+        en: {
+            fruits: {
+                apple: "apple",
+                orange: "orange",
+                grape: "grape"
+            }
+        },
+        es: {
+            fruits: {
+                apple: "manzana",
+                orange: "naranja",
+                grape: "uva"
+            }
+        }
+    });
+    ctx.locale("en");
+    assert.equal(ctx.t("fruits.apple"), "apple", "(en) fruits.apple");
+    assert.equal(ctx.t("fruits.orange"), "orange", "(en) fruits.orange");
+    assert.equal(ctx.t([
+        "fruits",
+        "grape"
+    ]), "grape", "(en) [\"fruits\",\"grape\"]");
+    assert.equal(ctx.t("fruits.404"), "", "(en) fruits.404 ~> \"\"");
+    assert.equal(ctx.t("error.404"), "", "(en) error.404 ~> \"\"");
+    ctx.locale("es");
+    assert.equal(ctx.t("fruits.apple"), "manzana", "(es) fruits.apple");
+    assert.equal(ctx.t("fruits.orange"), "naranja", "(es) fruits.orange");
+    assert.equal(ctx.t([
+        "fruits",
+        "grape"
+    ]), "uva", "(es) [\"fruits\",\"grape\"]");
+    assert.equal(ctx.t("fruits.404"), "", "(es) fruits.404 ~> \"\"");
+    assert.equal(ctx.t("error.404"), "", "(es) error.404 ~> \"\"");
+});
+test("arrays", function () {
+    var ctx = createTranslate({
+        en: {
+            foo: "{{0}} + {{1}} = {{2}}",
+            bar: [
+                {
+                    baz: "roses are {{colors.0}}, violets are {{colors.1}}"
+                }
+            ]
+        }
+    });
+    ctx.locale("en");
+    assert.equal(ctx.t("foo", [
+        1,
+        2,
+        3
+    ]), "1 + 2 = 3", "~> foo");
+    assert.equal(ctx.t("bar.0.baz", {
+        colors: [
+            "red",
+            "blue"
+        ]
+    }), "roses are red, violets are blue", "~> bar.0.baz");
+});
+test("invalid value", function () {
+    var ctx = createTranslate({
+        en: {
+            foo: [
+                "bar"
+            ]
+        }
+    });
+    assert.deepEqual(ctx.t("foo", null, "en"), [
+        "bar"
+    ]);
+});

package/lib/index.js

@@ -1,91 +1,91 @@
-import { Promises } from './asyncs/Promises.js';
+import { Promises } from "./asyncs/Promises.js";
 // arrays
-export { firstOfMaybeArray, lastOfMaybeArray, arrayOfMaybeArray, objectOfMaybeArray } from './arrays/MaybeArray.js';
-export { arrayFromAsync } from './arrays/arrayFromAsync.js';
+export { firstOfMaybeArray, lastOfMaybeArray, arrayOfMaybeArray, objectOfMaybeArray } from "./arrays/MaybeArray.js";
+export { arrayFromAsync } from "./arrays/arrayFromAsync.js";
 // object
-export { get } from './objects/get.js';
-export { set } from './objects/set.js';
-export { parseObjectPath } from './objects/parseObjectPath.js';
-export { computeIfAbsent } from './objects/computeIfAbsent.js';
-export { merge } from './objects/merge/index.js';
+export { get } from "./objects/get.js";
+export { set } from "./objects/set.js";
+export { parseObjectPath } from "./objects/parseObjectPath.js";
+export { computeIfAbsent } from "./objects/computeIfAbsent.js";
+export { merge } from "./objects/merge/index.js";
 // async
-export { createLazyPromise } from './asyncs/createLazyPromise.js';
-export { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval.js';
+export { createLazyPromise } from "./asyncs/createLazyPromise.js";
+export { setAsyncInterval, clearAsyncInterval } from "./asyncs/AsyncInterval.js";
 // async - iterator
-export { createAsyncIterator } from './asyncs/createAsyncIterator.js';
-export { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator.js';
-export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator.js';
-export { isIterator } from './asyncs/isIterator.js';
-export { Promises } from './asyncs/Promises.js';
-export const sleep = Promises.sleep;
-export const isPromise = Promises.isPromise;
-export { timeout, TimeoutError } from './asyncs/timeout.js';
+export { createAsyncIterator } from "./asyncs/createAsyncIterator.js";
+export { firstOfAsyncIterator } from "./asyncs/firstOfAsyncIterator.js";
+export { nextOfAsyncIterator } from "./asyncs/nextOfAsyncIterator.js";
+export { isIterator } from "./asyncs/isIterator.js";
+export { Promises } from "./asyncs/Promises.js";
+export var sleep = Promises.sleep;
+export var isPromise = Promises.isPromise;
+export { timeout, TimeoutError } from "./asyncs/timeout.js";
 // langs
-export { shallowEqual } from './langs/shallowEqual.js';
-export { deepEqual } from './langs/deepEqual.js';
-export { deepFreeze } from './langs/deepFreeze.js';
-export { classOf } from './langs/classOf.js';
-export { shallowClone } from './langs/shallowClone.js';
-export { isClass } from './langs/isClass.js';
-export { isDefined } from './langs/isDefined.js';
-export { isEmptyObject } from './langs/isEmptyObject.js';
-export { isPlainObject } from './langs/isPlainObject.js';
-export { parseBoolean } from './langs/parseBoolean.js';
-export { maybeFunction } from './langs/MaybeFunction.js';
-export { memoize } from './langs/memoize.js';
-export { mixin } from './langs/mixin.js';
-export { getObjectId } from './langs/getObjectId.js';
-export { getGlobalStates, setGlobalStates } from './langs/getGlobalStates.js';
-export { AsyncCloser } from './runtime/AsyncCloser.js';
-export { Closer } from './runtime/Closer.js';
-export { isUUID } from './validations/isUUID.js';
-export { parseTimestamp } from './validations/parseTimestamp.js';
+export { isNil } from "./langs/isNil.js";
+export { shallowEqual } from "./langs/shallowEqual.js";
+export { deepEqual } from "./langs/deepEqual.js";
+export { deepFreeze } from "./langs/deepFreeze.js";
+export { classOf } from "./langs/classOf.js";
+export { shallowClone } from "./langs/shallowClone.js";
+export { isClass } from "./langs/isClass.js";
+export { isDefined } from "./langs/isDefined.js";
+export { isEmptyObject } from "./langs/isEmptyObject.js";
+export { isPlainObject } from "./langs/isPlainObject.js";
+export { ifPresent } from "./langs/ifPresent.js";
+export { parseBoolean } from "./langs/parseBoolean.js";
+export { maybeFunction } from "./langs/MaybeFunction.js";
+export { memoize } from "./langs/memoize.js";
+export { mixin } from "./langs/mixin.js";
+export { getObjectId } from "./langs/getObjectId.js";
+export { getGlobalStates, setGlobalStates } from "./langs/getGlobalStates.js";
+export { AsyncCloser } from "./langs/AsyncCloser.js";
+export { Closer } from "./langs/Closer.js";
+export { isUUID } from "./validations/isUUID.js";
+export { parseTimestamp } from "./validations/parseTimestamp.js";
 // modules
-export { parseModuleId } from './modules/parseModuleId.js';
-export { isModule } from './modules/isModule.js';
-export { createLogger } from './logging/createLogger.js';
-export { createNoopLogger } from './logging/createNoopLogger.js';
-export { createChildLogger } from './logging/createChildLogger.js';
+export { parseModuleId } from "./modules/parseModuleId.js";
+export { isModule } from "./modules/isModule.js";
 // strings
-export { pascalCase, camelCase } from './strings/camelCase.js';
-export { renderTemplate } from './strings/renderTemplate.js';
-export { formatBytes } from './strings/formatBytes.js';
+export { pascalCase, camelCase } from "./strings/camelCase.js";
+export { renderTemplate } from "./strings/renderTemplate.js";
+export { formatBytes } from "./strings/formatBytes.js";
+export { parseBytes } from "./strings/parseBytes.js";
 // i18n
-export { createTranslate } from './i18n/createTranslate.js';
+export { createTranslate } from "./i18n/createTranslate.js";
 // io
-export { isBuffer } from './io/isBuffer.js';
-export { isTransferable } from './io/isTransferable.js';
-export { ArrayBuffers } from './io/ArrayBuffers.js';
-export { ByteBuffer } from './io/ByteBuffer.js';
-export { fromHexDump, toHexDump } from './io/dump.js';
-export { Buffer } from './io/Buffer.js';
-export { parseDataUri } from './io/parseDataUri.js';
+export { isBuffer } from "./io/isBuffer.js";
+export { isTransferable } from "./io/isTransferable.js";
+export { ArrayBuffers } from "./io/ArrayBuffers.js";
+export { ByteBuffer } from "./io/ByteBuffer.js";
+export { fromHexDump, toHexDump } from "./io/dump.js";
+export { Buffer } from "./io/Buffer.js";
+export { parseDataUri } from "./io/parseDataUri.js";
 // browser
-export { copy } from './browsers/copy.js';
-export { download } from './browsers/download.js';
-export { loadScripts, loadStyles } from './browsers/loaders.js';
-export { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer.js';
-// polyfills
-export { getGlobalThis } from './runtime/getGlobalThis.js';
-export { structuredClone } from './runtime/structuredClone.js';
+export { copy } from "./browsers/copy.js";
+export { download } from "./browsers/download.js";
+export { loadScripts, loadStyles } from "./browsers/loaders.js";
+export { getFileFromDataTransfer } from "./browsers/getFileFromDataTransfer.js";
+// web & spec
+export { requestIdleCallback, cancelIdleCallback } from "./web/requestIdleCallback.js";
+export { randomUUID } from "./web/randomUUID.js";
+export { getRandomValues } from "./web/getRandomValues.js";
+export { getGlobalThis } from "./web/getGlobalThis.js";
+export { structuredClone } from "./web/structuredClone.js";
 // crypto
-export { randomUUID } from './crypto/randomUUID.js';
-export { getRandomValues } from './crypto/getRandomValues.js';
-export { sha1, sha256, sha384, sha512, hmac } from './crypto/hashing.js';
-export { md5 } from './crypto/md5.js';
-export { hex } from './crypto/base.js';
-export { isULID, createULID, ulid, parseULID } from './crypto/ulid.js';
-export { PEM } from './crypto/pem/pem.js';
+export { sha1, sha256, sha384, sha512, hmac } from "./crypto/hashing.js";
+export { md5 } from "./crypto/md5.js";
+export { hex } from "./crypto/base.js";
+export { isULID, createULID, ulid, parseULID } from "./crypto/ulid.js";
+export { PEM } from "./crypto/pem/pem.js";
 // math
-export { createRandom } from './maths/random.js';
-export { clamp } from './maths/clamp.js';
+export { createRandom } from "./maths/random.js";
+export { clamp } from "./maths/clamp.js";
 // network
-export { createFetchWith, createFetchWithLogging, dumpResponse, dumpRequest, createFetchWithRetry } from './fetch/index.js';
+export { createFetchWith, createFetchWithLogging, dumpResponse, dumpRequest, createFetchWithRetry } from "./fetch/index.js";
 // bundled
-export { default as ms } from './libs/ms.js';
+export { default as ms } from "./libs/ms.js";
 // error
-export { Errors, DetailError } from './errors/Errors.js';
+export { Errors } from "./errors/Errors.js";
+export { DetailError } from "./errors/DetailError.js";
 // http
-export { getHttpStatusText, isRetryableHttpStatus } from './fetch/HttpStatus.js';
-
-//# sourceMappingURL=index.js.map
+export { getHttpStatusText, isRetryableHttpStatus } from "./fetch/HttpStatus.js";

package/lib/io/AbstractEncoding.js

@@ -3,5 +3,3 @@
  *
  * @see https://github.com/mafintosh/abstract-encoding
  */ export { };
-
-//# sourceMappingURL=AbstractEncoding.js.map

package/lib/io/ArrayBuffer.test-d.js

@@ -1,7 +1,5 @@
-import { expectTypeOf, test } from 'vitest';
-import { ArrayBuffers } from './ArrayBuffers.js';
-test('my types work properly', ()=>{
-    expectTypeOf(ArrayBuffers.asView(Buffer, new Uint8Array())).toMatchTypeOf();
+import { expectTypeOf, test } from "vitest";
+import { ArrayBuffers } from "./ArrayBuffers.js";
+test("my types work properly", function () {
+    expectTypeOf(ArrayBuffers.asView(Buffer, new Uint8Array())).toExtend();
 });
-
-//# sourceMappingURL=ArrayBuffer.test-d.js.map

package/lib/io/ArrayBuffers.base64.test.js

@@ -0,0 +1,60 @@
+import { assert, beforeAll, expect, test } from "vitest";
+import { ArrayBuffers } from "./ArrayBuffers.js";
+beforeAll(function () {
+    expect(ArrayBuffers.isNativeBufferAvailable()).toBeTruthy();
+    ArrayBuffers.setNativeBufferAllowed(false);
+});
+test("base64: ignore whitespace", function () {
+    var text = "\n   YW9ldQ==  ";
+    var buf = ArrayBuffers.from(text, "base64");
+    expect(ArrayBuffers.toString(buf)).toBe("aoeu");
+});
+test("base64: strings without padding", function () {
+    expect(ArrayBuffers.toString(ArrayBuffers.from("YW9ldQ", "base64"))).toBe("aoeu");
+});
+test("base64: newline in utf8 -- should not be an issue", function () {
+    assert.equal(ArrayBuffers.toString(ArrayBuffers.from("LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK", "base64"), "utf8"), "---\ntitle: Three dashes marks the spot\ntags:\n");
+});
+test("base64: newline in base64 -- should get stripped", function () {
+    assert.equal(ArrayBuffers.toString(ArrayBuffers.from("LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\nICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt", "base64"), "utf8"), "---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-");
+});
+test("base64: tab characters in base64 - should get stripped", function () {
+    assert.equal(ArrayBuffers.toString(ArrayBuffers.from("LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\t\t\t\tICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt", "base64"), "utf8"), "---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-");
+});
+test("base64: invalid non-alphanumeric characters -- should be stripped", function () {
+    expect(ArrayBuffers.toString(ArrayBuffers.from("!\"#$%&'()*,.:;<=>?@[\\]^`{|}~", "base64"), "utf8")).toBe("");
+});
+test("base64: high byte", function () {
+    var highByte = ArrayBuffers.from([
+        128
+    ]);
+    assert.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, "base64"), "base64"), highByte);
+});
+test("fromBase64", function () {
+    var text = "aoeu";
+    var buf = ArrayBuffers.from(text, "utf8", Uint8Array);
+    expect(ArrayBuffers.fromBase64(ArrayBuffers.toBase64(buf))).toEqual(buf);
+});
+test("fromHex", function () {
+    var text = "aoeu";
+    var buf = ArrayBuffers.from(text, "utf8", Uint8Array);
+    expect(ArrayBuffers.fromHex(ArrayBuffers.toHex(buf))).toEqual(buf);
+});
+test("toHex", function () {
+    var text = "aoeu";
+    var buf = ArrayBuffers.from(text, "utf8", Uint8Array);
+    expect(ArrayBuffers.toHex(buf)).toEqual("616f6575");
+});
+test("toBase64", function () {
+    var text = "aoeu";
+    var buf = ArrayBuffers.from(text, "utf8", Uint8Array);
+    expect(ArrayBuffers.toBase64(buf)).toEqual("YW9ldQ==");
+});
+test("base64: utf8 string", function () {
+    var text = "\u4F60\u597D";
+    // latin1 only
+    expect(function () {
+        return btoa(text);
+    }).toThrow("Invalid character");
+    expect(ArrayBuffers.toBase64(text)).toEqual("5L2g5aW9");
+});