min-heap-typed 1.37.9 → 1.38.1

package/src/types/utils/validate-type.ts

@@ -0,0 +1,35 @@
+export type KeyValueObject = {[key: string]: any};
+
+export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
+
+export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
+
+export type ObjectWithoutKey = Omit<KeyValueObject, 'key'>;
+
+export type ObjectWithNonNumberKey = {
+  [key: string]: any;
+  key: string | boolean | symbol | null | object | undefined;
+};
+
+export type ObjectWithNumberKey = {
+  [key: string]: any;
+  key: number;
+};
+
+export type RestrictValByKey =
+  | NonNumberNonObjectButDefined
+  | ObjectWithoutKey
+  | ObjectWithNonNumberKey
+  | ObjectWithNumberKey;
+
+export type DummyAny =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | object
+  | symbol
+  | void
+  | ((...args: []) => any)
+  | never;

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './utils';

package/src/utils/utils.ts

@@ -0,0 +1,86 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from '../types';
+
+export const uuidV4 = function () {
+  return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
+    const r = (Math.random() * 16) | 0,
+      v = c == 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+export const arrayRemove = function <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean): T[] {
+  let i = -1,
+    len = array ? array.length : 0;
+  const result = [];
+
+  while (++i < len) {
+    const value = array[i];
+    if (predicate(value, i, array)) {
+      result.push(value);
+      Array.prototype.splice.call(array, i--, 1);
+      len--;
+    }
+  }
+
+  return result;
+};
+
+export const THUNK_SYMBOL = Symbol('thunk');
+
+export const isThunk = (fnOrValue: any) => {
+  return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL;
+};
+
+export const toThunk = (fn: ToThunkFn): Thunk => {
+  const thunk = () => fn();
+  thunk.__THUNK__ = THUNK_SYMBOL;
+  return thunk;
+};
+
+export const trampoline = (fn: TrlFn) => {
+  const cont = (...args: [...Parameters<TrlFn>]) => toThunk(() => fn(...args));
+
+  return Object.assign(
+    (...args: [...Parameters<TrlFn>]) => {
+      let result = fn(...args);
+
+      while (isThunk(result) && typeof result === 'function') {
+        result = result();
+      }
+
+      return result;
+    },
+    {cont}
+  );
+};
+
+export const trampolineAsync = (fn: TrlAsyncFn) => {
+  const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args));
+
+  return Object.assign(
+    async (...args: [...Parameters<TrlAsyncFn>]) => {
+      let result = await fn(...args);
+
+      while (isThunk(result) && typeof result === 'function') {
+        result = await result();
+      }
+
+      return result;
+    },
+    {cont}
+  );
+};
+
+export const getMSB = (value: number): number => {
+  if (value <= 0) {
+    return 0;
+  }
+  return 1 << (31 - Math.clz32(value));
+};