@wener/utils 1.0.0-alpha.8 → 1.1.0

package/lib/esnext/validations/isEmptyObject.d.ts

@@ -0,0 +1 @@
+export declare function isEmptyObject(o: any): boolean;

package/lib/esnext/validations/isEmptyObject.js

@@ -0,0 +1,7 @@
+export function isEmptyObject(o) {
+    if (o === null || o === undefined) {
+        return true;
+    }
+    return o.constructor === Object && Object.keys(o).length === 0;
+}
+//# sourceMappingURL=isEmptyObject.js.map

package/lib/esnext/validations/isEmptyObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEmptyObject.js","sourceRoot":"","sources":["../../../src/validations/isEmptyObject.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,aAAa,CAAC,CAAM;IAClC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,EAAE;QACjC,OAAO,IAAI,CAAC;KACb;IACD,OAAO,CAAC,CAAC,WAAW,KAAK,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;AACjE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.0.0-alpha.8",
+  "version": "1.1.0",
   "description": "Utils for daily use",
   "keywords": [
     "utils",
@@ -9,17 +9,28 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/wener/apis.git"
+    "url": "git+https://github.com/wener/wode.git"
   },
   "license": "MIT",
   "author": "wener",
-  "main": "lib/index.js",
-  "umd:main": "dist/utils.umd.js",
-  "module": "dist/utils.es5.js",
-  "source": "src/index.ts",
-  "browser": "dist/utils.umd.js",
-  "typings": "lib/index.d.ts",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "types": "src/index.ts",
+  "esnext": "lib/esnext/index.js",
+  "umd:main": "dist/utils.js",
+  "unpkg": "dist/utils.js",
+  "jsdelivr": "dist/utils.js",
+  "jsnext:main": "dist/utils.esm.js",
+  "exports": {
+    ".": {
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    }
+  },
+  "homepage": "https://github.com/wenerme/wode#readme",
   "files": [
+    "index.js",
+    "index.d.ts",
     "lib",
     "dist",
     "src",
@@ -32,35 +43,28 @@
     "tsconfig.json"
   ],
   "scripts": {
-    "prebuild": "rm -rf ./lib ./dist",
-    "build": "tsc && rollup -c rollup.config.ts && typedoc --out docs --target es6 --theme minimal --mode file src",
-    "doc": "typedoc --out docs --target es6 --theme minimal --mode file src",
-    "prepare": "yarn build",
+    "build": "make build",
+    "clean": "make clean",
+    "dev": "make dev",
     "test": "jest"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^11.0.2",
-    "@rollup/plugin-json": "^4.0.2",
-    "@rollup/plugin-node-resolve": "^7.1.1",
-    "@rollup/plugin-typescript": "^4.0.0",
-    "@types/jest": "^25.1.4",
-    "@types/lodash": "^4.14.149",
-    "@types/node": "*",
-    "isomorphic-unfetch": "^3.0.0",
-    "jest": "^25.1.0",
-    "lodash": "^4.17.15",
-    "rollup": "^2.3.2",
-    "ts-jest": "^25.2.1",
-    "tslib": "^1.11.1",
-    "typedoc": "^0.17.3",
-    "typescript": "^3.8.3"
-  },
-  "optionalDependencies": {
-    "isomorphic-unfetch": "^3.0.0",
-    "lodash": "^4.17.15"
+    "@types/jest": "^27",
+    "@types/lodash": "^4",
+    "@types/node": "^16",
+    "dotenv": "^16",
+    "esbuild": "^0.14",
+    "jest": "^28",
+    "lodash": "^4",
+    "ts-jest": "^28",
+    "tslib": "^2",
+    "typescript": "^4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "af72bb31ee9b536c31fb9caeb8aa5349674cc136"
+  "engines": {
+    "node": "16",
+    "npm": "8"
+  }
 }

package/src/arrays/MaybeArray.ts

@@ -1,5 +1,18 @@
 export type MaybeArray<T> = T | T[];
 
+export function objectOfMaybeArray<T = any>(
+  o: Record<string, MaybeArray<T>>,
+  keys: string[] | null = null,
+  picker = firstOfMaybeArray
+): Record<string, T> {
+  if (keys === null) {
+    return Object.fromEntries(
+      Object.entries(o).map(([k, v]) => [k, picker(v)])
+    );
+  }
+  return Object.fromEntries(keys.map((v) => [v, picker(v)])) as any;
+}
+
 export function firstOfMaybeArray<T>(v: MaybeArray<T>): T {
   if (Array.isArray(v)) {
     return v[0];

package/src/asyncs/LazyPromise.ts

@@ -4,19 +4,26 @@ export type LazyPromise<T> = Promise<T> & {
 };
 
 export function createLazyPromise<T = any>(): LazyPromise<T> {
-  const promise: LazyPromise<T> = Object.assign(
+  const holder = {
+    resolve(_: any): void {
+      throw new Error('pending resolve');
+    },
+    reject(_: any): void {
+      throw new Error('pending reject');
+    },
+  };
+  return Object.assign(
     new Promise<T>((resolve, reject) => {
-      promise.reject = reject;
-      promise.resolve = resolve;
+      holder.reject = reject;
+      holder.resolve = resolve;
     }),
     {
-      resolve() {
-        throw new Error('pending resolve');
+      resolve(v: any) {
+        holder.resolve(v);
       },
-      reject() {
-        throw new Error('pending reject');
+      reject(v: any) {
+        holder.resolve(v);
       },
-    }
+    },
   );
-  return promise;
 }

package/src/asyncs/MaybePromise.ts

@@ -0,0 +1 @@
+export type MaybePromise<T> = Promise<T> | T;

package/src/asyncs/generatorOfStream.ts

@@ -0,0 +1,13 @@
+export function* generatorOfStream<T = any>(stream: any): IterableIterator<Promise<T>> {
+  let done = false;
+  stream.on('end', () => {
+    done = true;
+  });
+  while (!done) {
+    yield new Promise((resolve, reject) => {
+      stream.once('data', resolve);
+      stream.once('end', resolve);
+      stream.once('error', reject);
+    });
+  }
+}

package/src/asyncs/index.ts

@@ -1,3 +1,8 @@
-export * from './LazyPromise'
-export * from './AsyncInterval'
-export * from './sleep'
+export * from './LazyPromise';
+export * from './AsyncInterval';
+export * from './MaybePromise';
+
+export * from './sleep';
+export * from './timeout';
+export * from './isPromise';
+export * from './promiseOfCallback';

package/src/asyncs/isPromise.ts

@@ -0,0 +1,3 @@
+export function isPromise<T>(v: any): v is Promise<T> {
+  return v && (v instanceof Promise || (v.then && v.catch));
+}

package/src/asyncs/promiseOfCallback.ts

@@ -0,0 +1,15 @@
+export function promiseOfCallback<T>(fun: (cb: (err: any, val?: T) => void) => void) {
+  return new Promise<T>((resolve, reject) => {
+    try {
+      fun((e: any, v: any) => {
+        if (e) {
+          reject(e);
+        } else {
+          resolve(v);
+        }
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+}

package/src/asyncs/timeout.ts

@@ -0,0 +1,25 @@
+export function timeout<T = any>(v: Promise<T>, ms: number): Promise<T> {
+  const error = new TimeoutError();
+  let timeout: any;
+  return Promise.race([
+    v,
+    new Promise((_, reject) => {
+      timeout = setTimeout(() => reject(error), ms);
+    }),
+  ]).then(
+    (v) => {
+      clearTimeout(timeout);
+      return v;
+    },
+    (e) => {
+      clearTimeout(timeout);
+      throw e;
+    },
+  ) as Promise<T>;
+}
+
+export class TimeoutError extends Error {
+  constructor() {
+    super('TimeoutError');
+  }
+}

package/src/browsers/{transfers.ts → getFileFromDataTransfer.ts}

@@ -1,12 +1,17 @@
-export function getFile(dataTransfer: DataTransfer): { file: File; filename: string } | null {
-  const items: DataTransferItemList = dataTransfer?.items ?? ([] as any);
+export function getFileFromDataTransfer(dataTransfer?: DataTransfer | null): { file?: File; name?: string } {
+  if (!dataTransfer) {
+    return {};
+  }
+
+  const items: DataTransferItemList = dataTransfer.items ?? [];
 
   if (items.length >= 2 && items[0].kind === 'string' && items[1].kind === 'file') {
+    // name, file
     const text = dataTransfer.getData('text');
     const file = items[1].getAsFile() ?? dataTransfer.files?.item(0);
     if (!file) {
       console.error(`no file ${text}`, items[1]);
-      return null;
+      return {};
     }
 
     // let type = file.type;
@@ -18,19 +23,19 @@ export function getFile(dataTransfer: DataTransfer): { file: File; filename: str
     //   file = new File([blob], text, {type});
     // }
 
-    return { file, filename: text };
+    return { file, name: text };
   } else if (items[0].kind === 'file') {
     const file = items[0].getAsFile();
     if (!file) {
       console.error(`no file`, items[0]);
-      return null;
+      return {};
     }
-    return { file, filename: file.name };
+    return { file, name: file.name };
   } else {
     console.debug(
       `file item not match`,
-      Array.from(items).map((v) => ({ type: v.type, kind: v.kind }))
+      Array.from(items).map((v) => ({ type: v.type, kind: v.kind })),
     );
   }
-  return null;
+  return {};
 }

package/src/browsers/index.ts

@@ -1,4 +1,4 @@
-export * from './clipboard'
-export * from './download'
-export * from './loaders'
-export * from './transfers'
+export * from './copy';
+export * from './download';
+export * from './loaders';
+export * from './getFileFromDataTransfer';

package/src/browsers/loaders.ts

@@ -1,4 +1,9 @@
-function load(el: HTMLScriptElement | HTMLLinkElement, resolve: (v: any) => void, reject: Function, options: { attributes: Record<string, string> } | undefined) {
+function load(
+  el: HTMLScriptElement | HTMLLinkElement,
+  resolve: (v: any) => void,
+  reject: (v: any) => void,
+  options: { attributes: Record<string, string> } | undefined,
+) {
   el.onload = resolve;
   el.onerror = (e) => {
     el.remove();
@@ -23,7 +28,7 @@ export function loadScripts(src: string, options?: { attributes: Record<string,
 }
 
 export function loadStyles(href: string, options?: { attributes: Record<string, string> }) {
-  if (document.querySelector(`link[link="${href}"]`)) {
+  if (document.querySelector(`link[href="${href}"]`)) {
     return Promise.resolve();
   }
 

package/src/formats/formatBytes.ts

@@ -0,0 +1,30 @@
+/**
+ * Format bytes as human-readable text.
+ *
+ * @param bytes Number of bytes.
+ * @param si True to use metric (SI) units, aka powers of 1000. False to use
+ *           binary (IEC), aka powers of 1024.
+ * @param dp Number of decimal places to display.
+ *
+ * @return Formatted string.
+ */
+export function formatBytes(bytes: number, si = false, dp = 1) {
+  const thresh = si ? 1000 : 1024;
+
+  if (Math.abs(bytes) < thresh) {
+    return bytes + ' B';
+  }
+
+  const units = si
+    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+  let u = -1;
+  const r = 10 ** dp;
+
+  do {
+    bytes /= thresh;
+    ++u;
+  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
+
+  return bytes.toFixed(dp) + ' ' + units[u];
+}

package/src/index.ts

@@ -1,8 +1,10 @@
-export * from './arrays';
+export * from './arrays/index';
 export * from './asyncs';
 export * from './validations';
 export * from './strings';
 export * from './maths';
 export * from './io';
-export * from './envs';
-export * as Browsers from './browsers';
+export * from './browsers';
+export * from './isomorphics';
+
+export { formatBytes } from './formats/formatBytes';

package/src/isomorphics/getGlobalThis.ts

@@ -3,7 +3,7 @@ declare const global: typeof globalThis;
 /**
  * isomorphic globalThis
  *
- * globalThis supported by ff 65, chrome 71, node 12, babel
+ * globalThis supported by ff 65, Chrome 71, Node 12, babel
  *
  * @see https://caniuse.com/#search=globalThis
  * @see https://v8.dev/features/globalthis
@@ -13,8 +13,6 @@ export const getGlobalThis = (): typeof globalThis => {
   if (typeof self !== 'undefined') return self;
   if (typeof window !== 'undefined') return window;
   if (typeof global !== 'undefined') return global as any;
-  // eslint-disable-next-line
-  // @ts-ignore
-  if (typeof this !== 'undefined') return this;
+  // if (typeof this !== 'undefined') return this;
   throw new Error('Unable to locate global `this`');
 };

package/src/maths/random.ts

@@ -1,10 +1,10 @@
 /// javascript pseudo random
-export function createRandom({ seed = 0 } = {}) {
-  if (typeof seed === 'string') {
-    const s: string = seed;
+export function createRandom(o: { seed?: string | number } = {}) {
+  let seed = typeof o.seed === 'string' ? 0 : o.seed ?? 0;
+  if (typeof o.seed === 'string') {
     let sum = 0;
-    for (let i = 0; i < s.length; i++) {
-      sum += s.charCodeAt(i);
+    for (let i = 0; i < o.seed.length; i++) {
+      sum += o.seed.charCodeAt(i);
     }
     seed = sum;
   }

package/src/strings/camelCase.ts

@@ -41,8 +41,8 @@ export function pascalCase(input: string | string[]) {
 export function camelCase(
   input: string | string[],
   options: { pascalCase: boolean } = {
-    pascalCase: false
-  }
+    pascalCase: false,
+  },
 ) {
   if (!(typeof input === 'string' || Array.isArray(input))) {
     throw new TypeError('Expected the input to be `string | string[]`');

package/src/strings/index.ts

@@ -1,2 +1,3 @@
 export * from './camelCase';
 export * from './templates';
+export * from './urljoin';

package/src/strings/templates.ts

@@ -1,15 +1,13 @@
-import get from 'lodash/get';
-
 /**
  * 替换类似于 JS 的模板字符串
  *
  * @example
  * templateString('My name is ${name}',{name:'wener'})
  */
-export function templateString(template: string, variables: Record<string, any>) {
+export function templateString(template: string, getter: (v: string) => any) {
   return template.replace(/\${(.*?)}/g, (_, g) => {
     // variables[g.trim()]
     // 支持路径 - 例如 a.b[0]
-    return get(variables, g.trim());
+    return getter(g.trim());
   });
 }

package/src/strings/urljoin.test.ts

@@ -0,0 +1,5 @@
+import { urljoin } from './urljoin';
+
+test('join ext', () => {
+  expect(urljoin('http://wener.me/sub/', '/a/', '/hello.js')).toBe('http://wener.me/sub/a/hello.js');
+});

package/src/strings/urljoin.ts

@@ -0,0 +1,79 @@
+export function urljoin(...strArray: string[]);
+export function urljoin(strArray: string[]);
+
+/**
+ * @see {@link https://github.com/jfromaniello/url-join}
+ */
+export function urljoin(...args) {
+  let input;
+
+  if (typeof args[0] === 'object') {
+    input = args[0];
+  } else {
+    input = args;
+  }
+
+  return normalize(input);
+}
+
+function normalize(strArray: string[]) {
+  const resultArray: string[] = [];
+  if (strArray.length === 0) {
+    return '';
+  }
+
+  if (typeof strArray[0] !== 'string') {
+    throw new TypeError('Url must be a string. Received ' + strArray[0]);
+  }
+
+  // If the first part is a plain protocol, we combine it with the next part.
+  if (strArray[0].match(/^[^/:]+:\/*$/) && strArray.length > 1) {
+    const first = strArray.shift();
+    strArray[0] = first + strArray[0];
+  }
+
+  // There must be two or three slashes in the file protocol, two slashes in anything else.
+  if (strArray[0].match(/^file:\/\/\//)) {
+    strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, '$1:///');
+  } else {
+    strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, '$1://');
+  }
+
+  for (let i = 0; i < strArray.length; i++) {
+    let component = strArray[i];
+
+    if (typeof component !== 'string') {
+      throw new TypeError('Url must be a string. Received ' + component);
+    }
+
+    if (component === '') {
+      continue;
+    }
+
+    if (i > 0) {
+      // Removing the starting slashes for each component but the first.
+      component = component.replace(/^[\/]+/, '');
+    }
+    if (i < strArray.length - 1) {
+      // Removing the ending slashes for each component but the last.
+      component = component.replace(/[\/]+$/, '');
+    } else {
+      // For the last component we will combine multiple slashes to a single one.
+      component = component.replace(/[\/]+$/, '/');
+    }
+
+    resultArray.push(component);
+  }
+
+  let str = resultArray.join('/');
+  // Each input component is now separated by a single slash except the possible first plain protocol part.
+
+  // remove trailing slash before parameters or hash
+  str = str.replace(/\/(\?|&|#[^!])/g, '$1');
+
+  // replace ? in parameters with &
+  const parts = str.split('?');
+  str = parts.shift() + (parts.length > 0 ? '?' : '') + parts.join('&');
+
+  return str;
+}

package/src/validations/index.ts

@@ -1 +1,4 @@
 export * from './asserts';
+export * from './isDefined';
+export * from './isEmptyObject';
+export * from './isClass';

package/src/validations/isClass.ts

@@ -0,0 +1,3 @@
+export function isClass(func: any) {
+  return typeof func === 'function' && /^class\s/.test(Function.prototype.toString.call(func));
+}

package/src/validations/isDefined.ts

@@ -0,0 +1,3 @@
+export function isDefined<T = any>(v: T): v is NonNullable<T> {
+  return v !== null && v !== undefined;
+}

package/src/validations/isEmptyObject.ts

@@ -0,0 +1,6 @@
+export function isEmptyObject(o: any) {
+  if (o === null || o === undefined) {
+    return true;
+  }
+  return o.constructor === Object && Object.keys(o).length === 0;
+}

package/tsconfig.json

@@ -1,18 +1,38 @@
 {
   "compilerOptions": {
     "moduleResolution": "node",
-    "target": "es2019",
-    "module": "commonjs",
-    "lib": ["esnext", "dom"],
+    "target": "esnext",
+    "module": "esnext",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "es5",
+      "es2015.collection",
+      "es2015.iterable",
+      "esnext"
+    ],
     "strict": true,
     "sourceMap": true,
     "skipLibCheck": true,
     "declaration": true,
+    "esModuleInterop": true,
+    "importHelpers": true,
     "allowSyntheticDefaultImports": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
-    "outDir": "lib"
+    "noImplicitAny": false,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "pretty": true,
+    "removeComments": false,
+    "stripInternal": true
   },
-  "exclude": ["node_modules", "**/__tests__/*"],
-  "include": ["src"]
+  "exclude": [
+    "node_modules",
+    "**/__tests__/*"
+  ],
+  "include": [
+    "src"
+  ]
 }