@zk-tech/bedrock 0.0.1

package/src/function/debounce.ts

@@ -0,0 +1,168 @@
+interface DebounceSettings {
+  leading?: boolean | undefined;
+  maxWait?: number | undefined;
+  trailing?: boolean | undefined;
+}
+
+interface DebounceSettingsLeading extends DebounceSettings {
+  leading: true;
+}
+
+interface InvokeContext {
+  func: (...args: any[]) => any;
+  lastThis?: any;
+  lastArgs?: any[];
+  lastCallTime: number;
+  lastInvokeTime: number;
+  wait: number;
+
+  maxing: boolean;
+  maxWait: number;
+
+  leading: boolean;
+  trailing: boolean;
+  timerId?: any;
+  result: any;
+}
+
+function invokeFunc(context: InvokeContext, time: number) {
+  const args = context.lastArgs ?? [];
+  const thisArg = context.lastThis;
+  context.lastArgs = undefined;
+  context.lastThis = undefined;
+  context.lastInvokeTime = time;
+  context.result = context.func.apply(thisArg, args);
+  return context.result;
+}
+
+function leadingEdge(context: InvokeContext) {
+  // Reset any `maxWait` timer.
+  context.lastInvokeTime = context.lastCallTime;
+  // Start the timer for the trailing edge.
+  context.timerId = setTimeout(() => {
+    timerExpired(context);
+  }, context.wait);
+  // Invoke the leading edge.
+  return context.leading ? invokeFunc(context, context.lastCallTime) : context.result;
+}
+
+function remainingWait(context: InvokeContext, time: number) {
+  const timeSinceLastCall = time - context.lastCallTime;
+  const timeSinceLastInvoke = time - context.lastInvokeTime;
+  const timeWaiting = context.wait - timeSinceLastCall;
+
+  return context.maxing ? Math.min(timeWaiting, context.maxWait - timeSinceLastInvoke) : timeWaiting;
+}
+
+function shouldInvoke(context: InvokeContext, time: number): boolean {
+  const timeSinceLastCall = time - context.lastCallTime;
+  const timeSinceLastInvoke = time - context.lastInvokeTime;
+
+  return Boolean(
+    context.lastCallTime === 0 ||
+      timeSinceLastCall >= context.wait ||
+      timeSinceLastCall < 0 ||
+      (context.maxWait && timeSinceLastInvoke >= context.maxWait),
+  );
+}
+
+function timerExpired(context: InvokeContext) {
+  const time = Date.now();
+  if (shouldInvoke(context, time)) {
+    return trailingEdge(context, time);
+  }
+  // Restart the timer.
+  context.timerId = setTimeout(
+    () => {
+      timerExpired(context);
+    },
+    remainingWait(context, time),
+  );
+}
+
+function trailingEdge(context: InvokeContext, time: number) {
+  context.timerId = undefined;
+
+  if (context.trailing && context.lastArgs) {
+    return invokeFunc(context, time);
+  }
+  context.lastArgs = context.lastThis = undefined;
+  return context.result;
+}
+
+function cancel(context: InvokeContext) {
+  if (context.timerId !== undefined) {
+    clearTimeout(context.timerId);
+  }
+  context.lastInvokeTime = 0;
+  context.lastCallTime = 0;
+  context.lastArgs = undefined;
+  context.lastThis = undefined;
+  context.timerId = undefined;
+}
+
+function flush(context: InvokeContext) {
+  return context.timerId === undefined ? context.result : trailingEdge(context, Date.now());
+}
+
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  _wait?: number,
+  _options?: DebounceSettings | DebounceSettingsLeading,
+): {
+  (...args: Parameters<T>): ReturnType<T> | undefined;
+  cancel: () => void;
+  flush: () => ReturnType<T> | undefined;
+} {
+  const wait = _wait ?? 0;
+  const maxing = _options?.maxWait !== undefined;
+
+  const context: InvokeContext = {
+    func,
+    wait,
+    maxing,
+    maxWait: maxing ? Math.max(_options.maxWait ?? 0, wait) : wait,
+    leading: _options?.leading ?? false,
+    trailing: _options?.trailing ?? true,
+    lastInvokeTime: 0,
+    lastCallTime: 0,
+    result: undefined,
+  };
+
+  function debounced(...args: any[]) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(context, time);
+
+    context.lastThis = this;
+    context.lastArgs = args;
+    context.lastCallTime = time;
+
+    if (isInvoking) {
+      if (context.timerId === undefined) {
+        return leadingEdge(context);
+      }
+      if (_options?.maxWait !== undefined) {
+        // Handle invocations in a tight loop.
+        clearTimeout(context.timerId);
+        context.timerId = setTimeout(() => {
+          timerExpired(context);
+        }, wait);
+        return invokeFunc(context, context.lastCallTime);
+      }
+    }
+    if (context.timerId === undefined) {
+      context.timerId = setTimeout(() => {
+        timerExpired(context);
+      }, wait);
+    }
+    return context.result;
+  }
+
+  debounced.cancel = () => {
+    cancel(context);
+  };
+  debounced.flush = () => {
+    return flush(context);
+  };
+  return debounced;
+}

package/src/function/index.ts

@@ -0,0 +1,2 @@
+export { debounce } from './debounce';
+export { throttle } from './throttle';

package/src/function/node_modules/.vitest/results.json

@@ -0,0 +1 @@
+{"version":"1.0.1","results":[[":throttle.test.ts",{"duration":67,"failed":false}],[":debounce.test.ts",{"duration":0,"failed":false}]]}

package/src/function/throttle.test.ts

@@ -0,0 +1,179 @@
+/* eslint-disable max-lines-per-function */
+import { sleep } from '../async';
+import { throttle } from './throttle';
+
+describe('Throttle', () => {
+  test('should throttle a function', async () => {
+    let callCount = 0;
+    const throttled = throttle(() => {
+      callCount++;
+    }, 32);
+
+    throttled();
+    throttled();
+    throttled();
+
+    const lastCount = callCount;
+    expect(callCount).toBeGreaterThan(0);
+
+    await sleep(64);
+    expect(callCount).toBeGreaterThan(lastCount);
+  });
+
+  test('subsequent calls should return the result of the first call', async () => {    
+    const identity = (x: string) => x;
+    const throttled = throttle(identity, 32);
+    const results = [throttled('a'), throttled('b')];
+
+    expect(results).toEqual(['a', 'a']);
+
+    await sleep(64);
+
+    const newResults = [throttled('c'), throttled('d')];
+    expect(newResults[0]).not.toBe('a');
+    expect(newResults[0]).not.toBeUndefined();
+
+    expect(newResults[1]).not.toBe('d');
+    expect(newResults[1]).not.toBeUndefined();
+  });
+
+  test('should clear timeout when func is called', async () => {
+    let callCount = 0;
+
+    const throttled = throttle(() => {
+      callCount++;
+    }, 32);
+
+    throttled();
+    throttled();
+
+    await sleep(64);
+
+    expect(callCount).toBe(2);
+  });
+
+  test('should not trigger a trailing call when invoked once', async () => {
+    let callCount = 0;
+    const throttled = throttle(() => {
+      callCount++;
+    }, 32);
+
+    throttled();
+    expect(callCount).toBe(1);
+
+    await sleep(64);
+
+    expect(callCount).toBe(1);
+  });
+
+  test('should trigger a second throttled call as soon as possible', async () => {
+    expect.assertions(3);
+
+    let callCount = 0;
+    const throttled = throttle(() => {
+      callCount++;
+    }, 128, { leading: false });
+
+    throttled();
+
+    await sleep(192);
+    expect(callCount).toBe(1);
+    throttled();
+
+    await sleep(254 - 192);
+    expect(callCount).toBe(1);
+
+    await sleep(384 - 254);
+    expect(callCount).toBe(2);
+  });
+
+  test('should apply default options', async () => {
+    let callCount = 0;
+    const throttled = throttle(() => {
+      callCount++;
+    }, 32, {});
+
+    throttled();
+    throttled();
+    expect(callCount).toBe(1);
+
+    await sleep(128);
+    expect(callCount).toBe(2);
+  });
+
+  test('should support a leading option', () => {
+    const identity = (x: string) => x; // 确保identity函数定义已存在
+
+    // 含leading选项的throttle
+    const withLeading = throttle(identity, 32, { leading: true });
+    expect(withLeading('a')).toBe('a');
+
+    // 不含leading选项的throttle
+    const withoutLeading = throttle(identity, 32, { leading: false });
+    expect(withoutLeading('a')).toBeUndefined();
+  });
+
+  test('should support a trailing option', async () => {    
+    const withCount = vi.fn();
+    const withoutCount = vi.fn();
+
+    const withTrailing = throttle((value) => {
+      withCount();
+      return value;
+    }, 64, { trailing: true });
+
+    const withoutTrailing = throttle((value) => {
+      withoutCount();
+      return value;
+    }, 64, { trailing: false });
+
+    expect(withTrailing('a')).toBe('a');
+    expect(withTrailing('b')).toBe('a');
+
+    expect(withoutTrailing('a')).toBe('a');
+    expect(withoutTrailing('b')).toBe('a');
+
+    await sleep(256);
+
+    expect(withCount.mock.calls.length).toBe(2);
+    expect(withoutCount.mock.calls.length).toBe(1);
+  });
+
+  test('should not update lastCalled, at the end of the timeout, when trailing is false', async () => {
+    expect.assertions(1);
+
+    let callCount = 0;
+    
+    const throttled = throttle(() => {
+      callCount++;
+    }, 64, { trailing: false });
+
+    throttled();
+    throttled();
+
+    setTimeout(() => {
+      throttled();
+      throttled();
+    }, 96);
+
+    await sleep(192);
+
+    expect(callCount).toBeGreaterThan(1);
+  });
+
+  test('should work with a system time of 0', async () => {    
+    let callCount = 0;
+    const throttled = throttle((value) => {
+      callCount++;
+      return value;
+    }, 32);
+
+    const results = [throttled('a'), throttled('b'), throttled('c')];
+    expect(results).toEqual(['a', 'a', 'a']);
+    expect(callCount).toBe(1);
+
+    await sleep(64);
+
+    expect(callCount).toBe(2);
+  });
+});

package/src/function/throttle.ts

@@ -0,0 +1,26 @@
+import { debounce } from './debounce';
+
+interface ThrottleSettings {
+  leading?: boolean | undefined;
+  maxWait?: number | undefined;
+  trailing?: boolean | undefined;
+}
+
+export function throttle<T extends (...args: any[]) => any>(
+  func: T,
+  _wait?: number,
+  _options?: ThrottleSettings,
+) {
+  let leading = true;
+  let trailing = true;
+  if (_options) {
+    leading = _options.leading ?? leading;
+    trailing = _options.trailing ?? trailing;
+  }
+
+  return debounce(func, _wait, {
+    leading,
+    maxWait: _options?.maxWait,
+    trailing,
+  });
+}

package/src/hash/hash-t.test.ts

@@ -0,0 +1,100 @@
+import { numberHash, objectHash, stringHash } from './hash-t';
+
+describe('hash', () => {
+  it('numberHash', () => {
+    expect(numberHash(100)).toEqual(100);
+
+    expect(numberHash(-100)).toEqual(-100);
+
+    expect(numberHash(Number.MAX_SAFE_INTEGER)).toEqual(-1);
+
+    expect(numberHash(Number.MIN_SAFE_INTEGER)).toEqual(1);
+  });
+
+  it('stringHash', () => {
+    expect(stringHash('lvweb')).toEqual(-2198655);
+
+    expect(stringHash('lvweb yyds!')).toEqual(1937556723);
+
+    expect(stringHash('😀😀')).toEqual(-2038654673);
+
+    expect(stringHash('👩‍👩‍👧‍👧👩‍👩‍👧‍👧👩‍👩‍👧‍👧')).toEqual(-1143343164);
+  });
+
+  describe('objectHash', () => {
+    it('should return the correct hash for a given object', () => {
+      const inputObject = { key1: 'value1', key2: 42, key3: [1, 2, 3] };
+      const expectedHash = objectHash(inputObject); // 预期的哈希值
+
+      expect(objectHash(inputObject)).toEqual(expectedHash);
+    });
+
+    it('should return the same hash for objects with the same content', () => {
+      const inputObject1 = { key1: 'value1', key2: 42, key3: [1, 2, 3] };
+      const inputObject2 = { key3: [1, 2, 3], key1: 'value1', key2: 42 }; // 属性顺序不同
+      const expectedHash = objectHash(inputObject1);
+
+      expect(objectHash(inputObject1)).toEqual(expectedHash);
+      expect(objectHash(inputObject2)).toEqual(expectedHash);
+    });
+
+    it('should return different hashes for objects with different content', () => {
+      const inputObject1 = { key1: 'value1', key2: 42, key3: [1, 2, 3] };
+      const inputObject2 = { key1: 'value2', key2: 42, key3: [1, 2, 3] }; // 不同的内容
+      const expectedHash1 = objectHash(inputObject1);
+      const expectedHash2 = objectHash(inputObject2);
+
+      expect(objectHash(inputObject1)).toEqual(expectedHash1);
+      expect(objectHash(inputObject2)).toEqual(expectedHash2);
+      expect(expectedHash1).not.toEqual(expectedHash2);
+    });
+
+    it('should return the same hash for deeply nested arrays with the same content', () => {
+      const inputObject1 = {
+        key1: 'value1',
+        key2: 42,
+        key3: [
+          [1, 2, 3],
+          [4, 5, 6],
+        ],
+      };
+      const inputObject2 = {
+        key3: [
+          [1, 2, 3],
+          [4, 5, 6],
+        ],
+        key1: 'value1',
+        key2: 42,
+      }; // 属性顺序不同
+      const expectedHash = objectHash(inputObject1);
+
+      expect(objectHash(inputObject1)).toEqual(expectedHash);
+      expect(objectHash(inputObject2)).toEqual(expectedHash);
+    });
+
+    it('should return different hashes for objects with different nested arrays', () => {
+      const inputObject1 = {
+        key1: 'value1',
+        key2: 42,
+        key3: [
+          [1, 2, 3],
+          [4, 5, 6],
+        ],
+      };
+      const inputObject2 = {
+        key1: 'value1',
+        key2: 42,
+        key3: [
+          [1, 2, 3],
+          [4, 5, 7],
+        ],
+      }; // 不同的内容
+      const expectedHash1 = objectHash(inputObject1);
+      const expectedHash2 = objectHash(inputObject2);
+
+      expect(objectHash(inputObject1)).toEqual(expectedHash1);
+      expect(objectHash(inputObject2)).toEqual(expectedHash2);
+      expect(expectedHash1).not.toEqual(expectedHash2);
+    });
+  });
+});

package/src/hash/hash-t.ts

@@ -0,0 +1,51 @@
+function doHash(obj: any, hashVal: number): number {
+	switch (typeof obj) {
+		case 'object':
+			if (obj === null) {
+				return numberHash(349, hashVal);
+			} else if (Array.isArray(obj)) {
+				return arrayHash(obj, hashVal);
+			}
+			return objectHash(obj, hashVal);
+		case 'string':
+			return stringHash(obj, hashVal);
+		case 'boolean':
+			return booleanHash(obj, hashVal);
+		case 'number':
+			return numberHash(obj, hashVal);
+		case 'undefined':
+			return numberHash(937, hashVal);
+		default:
+			return numberHash(617, hashVal);
+	}
+}
+
+export function numberHash(val: number, initialHashVal = 0): number {
+  // 将原始的hash值扩大范围，结果强制为int32整数
+  return ((initialHashVal << 5) - initialHashVal + val) | 0;
+}
+
+export function arrayHash(arr: any[], initialHashVal: number): number {
+	initialHashVal = numberHash(104579, initialHashVal);
+	return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);
+}
+
+export function stringHash(s: string, hashVal = 0): number {
+  hashVal = numberHash(149417, hashVal);
+  for (let i = 0, {length} = s; i < length; i++) {
+    hashVal = numberHash(s.charCodeAt(i), hashVal);
+  }
+  return hashVal;
+}
+
+export function objectHash(obj: any, initialHashVal = 0): number {
+	initialHashVal = numberHash(181387, initialHashVal);
+	return Object.keys(obj).sort().reduce((hashVal, key) => {
+		hashVal = stringHash(key, hashVal);
+		return doHash(obj[key], hashVal);
+	}, initialHashVal);
+}
+
+export function booleanHash(b: boolean, initialHashVal: number): number {
+	return numberHash(b ? 433 : 863, initialHashVal);
+}

package/src/hash/index.ts

@@ -0,0 +1,3 @@
+export { stringHash } from './hash-t';
+export { numberHash } from './hash-t';
+export { objectHash } from './hash-t';

package/src/json/index.ts

@@ -0,0 +1 @@
+export { safeJsonParse } from './parse';

package/src/json/node_modules/.vitest/results.json

@@ -0,0 +1 @@
+{"version":"1.0.1","results":[[":parse.test.ts",{"duration":3,"failed":false}]]}

package/src/json/parse.ts

@@ -0,0 +1,19 @@
+import { lvAssert } from '@/assert';
+
+/**
+ * 解析 json 字符串，如果解析失败，返回空对象。
+ * @param value 序列化后的 json 字符串，注意，一定是json字符串
+ * @returns 反序列化的 json 字符串对应的对象，如果解析异常，返回空对象
+ */
+export function safeJsonParse(value: string, fallback: Record<string, any> = {}): Record<string, any> {
+  if (!value) {
+    return fallback;
+  }
+
+  try {
+    lvAssert(typeof value === 'string');
+    return JSON.parse(value);
+  } catch (e) {
+    return fallback;
+  }
+}

package/src/launch/abstract-job.ts

@@ -0,0 +1,45 @@
+import { Barrier } from '@/async';
+
+export abstract class AbstractJob<T, K extends T = T> {
+  protected abstract _name: string;
+  protected _store: Map<K, Barrier[]> = new Map();
+
+  get name() {
+    return this._name;
+  }
+
+  shouldWait(phase: K) {
+    const barriers = this._store.get(phase);
+    if (!barriers?.length) {
+      return false;
+    }
+    return true;
+  }
+
+  wait(phase: K): Promise<void> {
+    try {
+      const barriers = this._store.get(phase);
+      if (!barriers?.length) {
+        return Promise.resolve();
+      }
+      return Promise.all(barriers.map((barrier) => barrier.wait())) as unknown as Promise<void>;
+    } finally {
+      // 执行之后就清空，确保失败或cancel态时可以重复 prepare.
+      this._store.delete(phase);
+    }
+  }
+
+  prepare(phase: K) {
+    this._executePhase(phase);
+  }
+
+  protected _setBarrier(phase: K, barrier: Barrier) {
+    if (!this._store.has(phase)) {
+      this._store.set(phase, []);
+    }
+    const barriers = this._store.get(phase)!;
+    barriers.push(barrier);
+  }
+
+  protected abstract _executePhase(phase: K): void;
+}

package/src/launch/cost-recorder.ts

@@ -0,0 +1,22 @@
+// lifecycle -> cost
+// 启动流程lifecycle某个阶段对应的耗时
+type Trace = Record<string | number, number>;
+
+export class CostRecorder {
+  // 每个job在不同阶段的耗时
+  private _jobCost: Record<string, Trace> = {};
+
+  record(jobName: string, lifecycle: string | number, cost: number) {
+    if (!this._jobCost[jobName]) {
+      this._jobCost[jobName] = {};
+    }
+    if (!this._jobCost[jobName][lifecycle]) {
+      this._jobCost[jobName][lifecycle] = 0;
+    }
+    this._jobCost[jobName][lifecycle] += cost;
+  }
+
+  toString() {
+    return JSON.stringify(this._jobCost);
+  }
+}

package/src/launch/index.ts

@@ -0,0 +1,2 @@
+export { AbstractJob } from './abstract-job';
+export { JobScheduler } from './job-scheduler';