@pezkuwi/util 14.0.23 → 14.0.26

package/build-deno/logger.ts

@@ -1,160 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-import type { Logger } from './types.ts';
-
-import { xglobal } from 'https://deno.land/x/pezkuwi/x-global/mod.ts';
-
-import { formatDate } from './format/formatDate.ts';
-import { isBn } from './is/bn.ts';
-import { isBuffer } from './is/buffer.ts';
-import { isFunction } from './is/function.ts';
-import { isObject } from './is/object.ts';
-import { isU8a } from './is/u8a.ts';
-import { u8aToHex } from './u8a/toHex.ts';
-import { u8aToU8a } from './u8a/toU8a.ts';
-import { noop } from './noop.ts';
-
-type ConsoleType = 'error' | 'log' | 'warn';
-type LogType = ConsoleType | 'debug';
-
-const logTo = {
-  debug: 'log',
-  error: 'error',
-  log: 'log',
-  warn: 'warn'
-} as const;
-
-function formatOther (value: unknown): unknown {
-  if (value && isObject(value) && value.constructor === Object) {
-    const result: Record<string, unknown> = {};
-
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = loggerFormat(v);
-    }
-
-    return result;
-  }
-
-  return value;
-}
-
-export function loggerFormat (value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map(loggerFormat);
-  } else if (isBn(value)) {
-    return value.toString();
-  } else if (isU8a(value) || isBuffer(value)) {
-    return u8aToHex(u8aToU8a(value));
-  }
-
-  return formatOther(value);
-}
-
-function formatWithLength (maxLength: number): (v: unknown) => unknown {
-  return (v: unknown): unknown => {
-    if (maxLength <= 0) {
-      return v;
-    }
-
-    const r = `${v as string}`;
-
-    return r.length < maxLength
-      ? v
-      : `${r.substring(0, maxLength)} ...`;
-  };
-}
-
-function apply (log: LogType, type: string, values: unknown[], maxSize = -1): void {
-  if (values.length === 1 && isFunction(values[0])) {
-    const fnResult = values[0]() as unknown;
-
-    return apply(log, type, Array.isArray(fnResult) ? fnResult : [fnResult], maxSize);
-  }
-
-  console[logTo[log]](
-    formatDate(new Date()),
-    type,
-    ...values
-      .map(loggerFormat)
-      .map(formatWithLength(maxSize))
-  );
-}
-
-function isDebugOn (e: string, type: string): boolean {
-  return !!e && (
-    e === '*' ||
-    type === e ||
-    (
-      e.endsWith('*') &&
-      type.startsWith(e.slice(0, -1))
-    )
-  );
-}
-
-function isDebugOff (e: string, type: string): boolean {
-  return !!e && (
-    e.startsWith('-') &&
-    (
-      type === e.slice(1) ||
-      (
-        e.endsWith('*') &&
-        type.startsWith(e.slice(1, -1))
-      )
-    )
-  );
-}
-
-function getDebugFlag (env: readonly string[], type: string): boolean {
-  let flag = false;
-
-  for (const e of env) {
-    if (isDebugOn(e, type)) {
-      flag = true;
-    } else if (isDebugOff(e, type)) {
-      flag = false;
-    }
-  }
-
-  return flag;
-}
-
-function parseEnv (type: string): [boolean, number] {
-  const maxSize = parseInt(xglobal.process?.env?.['DEBUG_MAX'] || '-1', 10);
-
-  return [
-    getDebugFlag((xglobal.process?.env?.['DEBUG'] || '').toLowerCase().split(','), type),
-    isNaN(maxSize)
-      ? -1
-      : maxSize
-  ];
-}
-
-/**
- * @name Logger
- * @summary Creates a consistent log interface for messages
- * @description
- * Returns a `Logger` that has `.log`, `.error`, `.warn` and `.debug` (controlled with environment `DEBUG=typeA,typeB`) methods. Logging is done with a consistent prefix (type of logger, date) followed by the actual message using the underlying console.
- * @example
- * <BR>
- *
- * ```javascript
- * import { logger } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * const l = logger('test');
- * ```
- */
-export function logger (origin: string): Logger {
-  const type = `${origin.toUpperCase()}:`.padStart(16);
-  const [isDebug, maxSize] = parseEnv(origin.toLowerCase());
-
-  return {
-    debug: isDebug
-      ? (...values: unknown[]) => apply('debug', type, values, maxSize)
-      : noop,
-    error: (...values: unknown[]) => apply('error', type, values),
-    log: (...values: unknown[]) => apply('log', type, values),
-    noop,
-    warn: (...values: unknown[]) => apply('warn', type, values)
-  };
-}

package/build-deno/memoize.ts

@@ -1,46 +0,0 @@
-
-import type { Memoized } from './types.ts';
-
-import { stringify } from './stringify.ts';
-
-interface Options {
-  getInstanceId?: () => string;
-}
-
-function defaultGetId (): string {
-  return 'none';
-}
-
-/**
- * @name memoize
- * @description Memomize the function with a specific instanceId
- */
-export function memoize <T, F extends (...args: any[]) => T> (fn: F, { getInstanceId = defaultGetId }: Options = {}): Memoized<F> {
-  const cache: Record<string, Record<string, T>> = {};
-
-  const memoized = (...args: unknown[]): T => {
-    const stringParams = stringify(args);
-    const instanceId = getInstanceId();
-
-    if (!cache[instanceId]) {
-      cache[instanceId] = {};
-    }
-
-    if (cache[instanceId][stringParams] === undefined) {
-      cache[instanceId][stringParams] = fn(...args);
-    }
-
-    return cache[instanceId][stringParams];
-  };
-
-  memoized.unmemoize = (...args: unknown[]): void => {
-    const stringParams = stringify(args);
-    const instanceId = getInstanceId();
-
-    if (cache[instanceId]?.[stringParams] !== undefined) {
-      delete cache[instanceId][stringParams];
-    }
-  };
-
-  return memoized as Memoized<F>;
-}

package/build-deno/mod.ts

@@ -1,2 +0,0 @@
-
-export * from './index.ts';

package/build-deno/nextTick.ts

@@ -1,24 +0,0 @@
-
-/**
- * @name nextTick
- * @description Defer the operation to the queue for evaluation on the next tick
- */
-export function nextTick (onExec: () => unknown, onError?: (error: Error) => unknown): void {
-  // While Promise.resolve().then(...) would defer to the nextTick, this
-  // actually does not play as nicely in browsers like the setTimeout(...)
-  // approach. So the safer, though less optimal approach is the one taken here
-  setTimeout((): void => {
-    Promise
-      .resolve()
-      .then((): void => {
-        onExec();
-      })
-      .catch((error: Error): void => {
-        if (onError) {
-          onError(error);
-        } else {
-          console.error(error);
-        }
-      });
-  }, 0);
-}

package/build-deno/noop.ts

@@ -1,14 +0,0 @@
-
-/**
- * A sharable identity function. Returns the input as-is with no transformation applied.
- */
-export function identity <T> (value: T): T {
-  return value;
-}
-
-/**
- * A sharable noop function. As the name suggests, does nothing
- */
-export function noop (): void {
-  // noop
-}

package/build-deno/number/index.ts

@@ -1,7 +0,0 @@
-
-/**
- * @summary Utility methods to convert to and from `number` values
- */
-
-export { numberToHex } from './toHex.ts';
-export { numberToU8a } from './toU8a.ts';

package/build-deno/number/toHex.ts

@@ -1,25 +0,0 @@
-
-import type { HexString } from '../types.ts';
-
-import { hexFixLength } from '../hex/fixLength.ts';
-
-/**
- * @name numberToHex
- * @summary Creates a hex value from a number.
- * @description
- * `null`/`undefined`/`NaN` inputs returns an empty `0x` result. `number` input values return the actual bytes value converted to a `hex`. With `bitLength` set, it converts the number to the equivalent size.
- * @example
- * <BR>
- *
- * ```javascript
- * import { numberToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * numberToHex(0x1234); // => '0x1234'
- * numberToHex(0x1234, 32); // => 0x00001234
- * ```
- */
-export function numberToHex (value?: number | null, bitLength = -1): HexString {
-  const hex = (!value || Number.isNaN(value) ? 0 : value).toString(16);
-
-  return hexFixLength(hex.length % 2 ? `0${hex}` : hex, bitLength, true);
-}

package/build-deno/number/toU8a.ts

@@ -1,23 +0,0 @@
-
-import { hexToU8a } from '../hex/toU8a.ts';
-import { numberToHex } from './toHex.ts';
-
-/**
- * @name numberToU8a
- * @summary Creates a Uint8Array object from a number.
- * @description
- * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `number` input values return the actual bytes value converted to a `Uint8Array`. With `bitLength`, it converts the value to the equivalent size.
- * @example
- * <BR>
- *
- * ```javascript
- * import { numberToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * numberToU8a(0x1234); // => [0x12, 0x34]
- * ```
- */
-export function numberToU8a (value?: number | null, bitLength = -1): Uint8Array {
-  return hexToU8a(
-    numberToHex(value, bitLength)
-  );
-}

package/build-deno/object/clear.ts

@@ -1,14 +0,0 @@
-
-/**
- * @name objectClear
- * @summary Removes all the keys from the input object
- */
-export function objectClear <T> (value: Record<string, T>): Record<string, T> {
-  const keys = Object.keys(value);
-
-  for (let i = 0, count = keys.length; i < count; i++) {
-    delete value[keys[i]];
-  }
-
-  return value;
-}

package/build-deno/object/copy.ts

@@ -1,10 +0,0 @@
-
-import { objectSpread } from './spread.ts';
-
-/**
- * @name objectCopy
- * @summary Creates a shallow clone of the input object
- */
-export function objectCopy <T extends object> (source: T): T {
-  return objectSpread({}, source);
-}

package/build-deno/object/entries.ts

@@ -1,10 +0,0 @@
-
-type Entries<T> = { [K in keyof T]: [K, T[K]] }[keyof T][];
-
-/**
- * @name objectEntries
- * @summary A version of Object.entries that is typed for TS
- */
-export function objectEntries<T extends object> (obj: T): Entries<T> {
-  return Object.entries(obj) as Entries<T>;
-}

package/build-deno/object/index.ts

@@ -1,8 +0,0 @@
-
-export { objectClear } from './clear.ts';
-export { objectCopy } from './copy.ts';
-export { objectEntries } from './entries.ts';
-export { objectKeys } from './keys.ts';
-export { objectProperties, objectProperty } from './property.ts';
-export { objectSpread } from './spread.ts';
-export { objectValues } from './values.ts';

package/build-deno/object/keys.ts

@@ -1,8 +0,0 @@
-
-/**
- * @name objectKeys
- * @summary A version of Object.keys that is typed for TS
- */
-export function objectKeys<T extends object, K extends Extract<keyof T, string>> (value: T): K[] {
-  return Object.keys(value) as K[];
-}

package/build-deno/object/property.ts

@@ -1,37 +0,0 @@
-
-/**
- * @name objectProperty
- * @summary Assign a get property on the input object
- */
-export function objectProperty <S> (that: object, key: string, getter: (key: string, index: number, self: S) => unknown, getName?: (key: string, index: number) => string, index = 0): void {
-  const name = getName
-    ? getName(key, index)
-    : key;
-
-  // There are 3 approaches here -
-  //  - Object.prototype.hasOwnProperty.call(that, key) - this only checks the current class, i.e
-  //    will retuirn false if the property is set in the parent class
-  //  - isUndefined(...) - this may yield a false positive when the property is there, but not set.
-  //    Additionally, on pre-defined getters it may make a call
-  //  - key in that - Does not need to be combined with either of the above and checks the full chain
-  if (!(name in that)) {
-    Object.defineProperty(that, name, {
-      enumerable: true,
-      // Unlike in lazy, we always call into the upper function, i.e. this method
-      // does not cache old values (it is expected to be used for dynamic values)
-      get: function (): unknown {
-        return getter(key, index, this as S);
-      }
-    });
-  }
-}
-
-/**
- * @name objectProperties
- * @summary Assign get properties on the input object
- */
-export function objectProperties <S> (that: object, keys: string[], getter: (key: string, index: number, self: S) => unknown, getName?: (key: string, index: number) => string): void {
-  for (let i = 0, count = keys.length; i < count; i++) {
-    objectProperty(that, keys[i], getter, getName, i);
-  }
-}

package/build-deno/object/spread.ts

@@ -1,36 +0,0 @@
-
-/**
- * @name objectSpread
- * @summary Concats all sources into the destination
- * @description Spreads object properties while maintaining object integrity
- */
-export function objectSpread <T extends object> (dest: object, ...sources: (object | undefined | null)[]): T {
-  const filterProps = new Set(['__proto__', 'constructor', 'prototype']);
-
-  for (let i = 0, count = sources.length; i < count; i++) {
-    const src = sources[i];
-
-    if (src) {
-      if (typeof (src as Map<string, unknown>).entries === 'function') {
-        for (const [key, value] of (src as Map<string, unknown>).entries()) {
-          if (!filterProps.has(key)) {
-            (dest as Record<string, unknown>)[key] = value;
-          }
-        }
-      } else {
-        // Create a clean copy of the source object
-        const sanitizedSrc = Object.create(null) as Record<string, unknown>;
-
-        for (const [key, value] of Object.entries(src)) {
-          if (!filterProps.has(key)) {
-            sanitizedSrc[key] = value;
-          }
-        }
-
-        Object.assign(dest, sanitizedSrc);
-      }
-    }
-  }
-
-  return dest as T;
-}

package/build-deno/object/values.ts

@@ -1,8 +0,0 @@
-
-/**
- * @name objectValues
- * @summary A version of Object.values that is typed for TS
- */
-export function objectValues<T extends object> (obj: T): T[keyof T][] {
-  return Object.values(obj) as T[keyof T][];
-}

package/build-deno/packageDetect.ts

@@ -1,9 +0,0 @@
-
-
-import { packageInfo as decoderInfo } from 'https://deno.land/x/pezkuwi/x-textdecoder/mod.ts';
-import { packageInfo as encoderInfo } from 'https://deno.land/x/pezkuwi/x-textencoder/mod.ts';
-
-import { detectPackage } from './detectPackage.ts';
-import { packageInfo } from './packageInfo.ts';
-
-detectPackage(packageInfo, null, [decoderInfo, encoderInfo]);

package/build-deno/packageInfo.ts

@@ -1,3 +0,0 @@
-
-
-export const packageInfo = { name: '@pezkuwi/util', path: new URL(import.meta.url).pathname, type: 'deno', version: '14.0.23' };

package/build-deno/promisify.ts

@@ -1,27 +0,0 @@
-
-/**
- * @name promisify
- * @summary Wraps an async callback into a `Promise`
- * @description
- * Wraps the supplied async function `fn` that has a standard JS callback `(error: Error, result: any)` into a `Promise`, passing the supplied parameters. When `error` is set, the Promise is rejected, else the Promise resolves with the `result` value.
- * @example
- * <BR>
- *
- * ```javascript
- * const { promisify } from '@pezkuwi/util';
- *
- * await promisify(null, ((a, cb) => cb(null, a), true); // resolves with `true`
- * await promisify(null, (cb) => cb(new Error('error!'))); // rejects with `error!`
- * ```
- */
-export function promisify <R = any> (self: unknown, fn: (...params: any[]) => any, ...params: any[]): Promise<R> {
-  return new Promise((resolve, reject): void => {
-    fn.apply(self, params.concat((error: Error | null, result?: R): void => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(result as R);
-      }
-    }));
-  });
-}

package/build-deno/string/camelCase.ts

@@ -1,77 +0,0 @@
-
-import type { AnyString } from '../types.ts';
-
-export const CC_TO_UP = new Array<string>(256);
-export const CC_TO_LO = new Array<string>(256);
-
-for (let i = 0, count = CC_TO_UP.length; i < count; i++) {
-  CC_TO_LO[i] = String.fromCharCode(i).toLowerCase();
-  CC_TO_UP[i] = String.fromCharCode(i).toUpperCase();
-}
-
-/** @internal */
-function formatAllCaps (w: string): string {
-  return w.slice(0, w.length - 1).toLowerCase() + CC_TO_UP[w.charCodeAt(w.length - 1)];
-}
-
-/**
- * @internal
- *
- * Inspired by https://stackoverflow.com/a/2970667
- *
- * This is not as optimal as the original SO answer (we split into per-word),
- * however it does pass the tests (which the SO version doesn't) and is still
- * a major improvement over the original camelcase npm package -
- *
- *   camelcase: 20.88 μs/op
- *        this:  1.00 μs/op
- *
- * Caveat of this: only Ascii, but acceptable for the intended usecase
- */
-function converter (format: (w: string, i: number) => string): (value: AnyString) => string {
-  return (value: AnyString): string => {
-    const parts = value
-      // replace all separators (including consequtive) with spaces
-      .replace(/[-_., ]+/g, ' ')
-      // we don't want leading or trailing spaces
-      .trim()
-      // split into words
-      .split(' ');
-    let result = '';
-
-    for (let i = 0, count = parts.length; i < count; i++) {
-      const w = parts[i];
-
-      // apply the formatting
-      result += format(
-        /^[\dA-Z]+$/.test(w)
-          // all full uppercase + letters are changed to lowercase
-          ? w.toLowerCase()
-          // all consecutive capitals + letters are changed to lowercase
-          // e.g. UUID64 -> uuid64, while preserving splits, eg. NFTOrder -> nftOrder
-          : w.replace(/^[\dA-Z]{2,}[^a-z]/, formatAllCaps),
-        i
-      );
-    }
-
-    return result;
-  };
-}
-
-/**
- * @name stringCamelCase
- * @summary Convert a dash/dot/underscore/space separated Ascii string/String to camelCase
- */
-export const stringCamelCase = /*#__PURE__*/ converter((w, i) =>
-  // lowercase for first letter/first word, else uppercase first, rest unchanged
-  (i ? CC_TO_UP[w.charCodeAt(0)] : CC_TO_LO[w.charCodeAt(0)]) + w.slice(1)
-);
-
-/**
- * @name stringPascalCase
- * @summary Convert a dash/dot/underscore/space separated Ascii string/String to PascalCase
- */
-export const stringPascalCase = /*#__PURE__*/ converter((w) =>
-  // uppercase the first character, leave the rest unchanged
-  CC_TO_UP[w.charCodeAt(0)] + w.slice(1)
-);

package/build-deno/string/index.ts

@@ -1,10 +0,0 @@
-
-/**
- * @summary Utility methods to convert to work with `string` values
- */
-
-export { stringCamelCase, stringPascalCase } from './camelCase.ts';
-export { stringLowerFirst, stringUpperFirst } from './lowerFirst.ts';
-export { stringShorten } from './shorten.ts';
-export { stringToHex } from './toHex.ts';
-export { stringToU8a } from './toU8a.ts';

package/build-deno/string/lowerFirst.ts

@@ -1,44 +0,0 @@
-
-import type { AnyString } from '../types.ts';
-
-import { CC_TO_LO, CC_TO_UP } from './camelCase.ts';
-
-/** @internal */
-function converter (map: readonly string[]): (value?: AnyString | null) => string {
-  return (value?: AnyString | null): string =>
-    value
-      ? map[value.charCodeAt(0)] + value.slice(1)
-      : '';
-}
-
-/**
- * @name stringLowerFirst
- * @summary Lowercase the first letter of a string
- * @description
- * Lowercase the first letter of a string
- * @example
- * <BR>
- *
- * ```javascript
- * import { stringLowerFirst } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * stringLowerFirst('ABC'); // => 'aBC'
- * ```
- */
-export const stringLowerFirst = /*#__PURE__*/ converter(CC_TO_LO);
-
-/**
- * @name stringUpperFirst
- * @summary Uppercase the first letter of a string
- * @description
- * Lowercase the first letter of a string
- * @example
- * <BR>
- *
- * ```javascript
- * import { stringUpperFirst } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * stringUpperFirst('abc'); // => 'Abc'
- * ```
- */
-export const stringUpperFirst = /*#__PURE__*/ converter(CC_TO_UP);

package/build-deno/string/shorten.ts

@@ -1,22 +0,0 @@
-
-import type { AnyString } from '../types.ts';
-
-/**
- * @name stringShorten
- * @summary Returns a string with maximum length
- * @description
- * Checks the string against the `prefixLength`, if longer than double this, shortens it by placing `..` in the middle of it
- * @example
- * <BR>
- *
- * ```javascript
- * import { stringShorten } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * stringShorten('1234567890', 2); // => 12..90
- * ```
- */
-export function stringShorten (value: AnyString, prefixLength = 6): string {
-  return value.length <= 2 + 2 * prefixLength
-    ? value.toString()
-    : `${value.substring(0, prefixLength)}…${value.slice(-prefixLength)}`;
-}

package/build-deno/string/toHex.ts

@@ -1,25 +0,0 @@
-
-import type { AnyString, HexString } from '../types.ts';
-
-import { u8aToHex } from '../u8a/toHex.ts';
-import { stringToU8a } from './toU8a.ts';
-
-/**
- * @name stringToHex
- * @summary Creates a hex string from a utf-8 string
- * @description
- * String input values return the actual encoded hex value.
- * @example
- * <BR>
- *
- * ```javascript
- * import { stringToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * stringToU8a('hello'); // 0x68656c6c6f
- * ```
- */
-export function stringToHex (value?: AnyString): HexString {
-  return u8aToHex(
-    stringToU8a(value)
-  );
-}