forivall

import type { Primitive } from 'type-fest';
interface TypeguardTuple<T> extends Omit<readonly [T, ...T[]], never> {
  includes(searchElement: unknown): searchElement is T;
  includes(searchElement: T, fromIndex?: number): boolean;
}
const typeguardTuple = <T extends Primitive>(tuple: readonly [T, ...T[]]) =>
  tuple as Omit<readonly [T, ...T[]], never> as TypeguardTuple<T>;

forivall

import { ObjectId } from 'bson';

export class ObjectIdSet {
  map = new Map<number, Set<number>>();
  constructor(values: Iterable<ObjectId>) {
    for (const value of values) {
      this.add(value);
    }
  }
  add(value: ObjectId): this {

forivall

const port = process.argv[2];
const host = process.argv[3];

const delay = 1000;
const socket = new net.Socket();
socket.on('close', () => {
  setTimeout(() => {
    socket.connect(port, host);
  }, delay);
});

forivall

function analyseObjectId(/** @type {import('bson').ObjectId} */ oid) {
  const randomidBuffer = Buffer.from(
    oid.buffer.buffer,
    oid.buffer.byteOffset + 4,
    5,
  );
  const counterBuffer = Buffer.alloc(4);
  oid.buffer.copy(counterBuffer, 1, 9);
  return {
    timestamp: oid.buffer.readInt32BE(0),

forivall

// just for hacking about in the node.js repl

PackFileCacheStrategy = require('webpack/lib/cache/PackFileCacheStrategy')
logger = Object.assign(Object.create(console), {getChildLogger() { return this }})
cacheLocation = '.angular/cache/17.3.8/angular-webpack/INSERT_HASH_HERE'
packStrategy = new PackFileCacheStrategy({version: '', cacheLocation, fs, compiler: { options: { output: {} } }, snapshot: {}, logger});
pack = await packStrategy.packPromise

forivall

/* This is equivalent to Map.groupBy; replace this function with Map.groupBy in Node 21+ */
function mapGroupBy<T, K>(array: T[], iteratee: (value: T, index: number, array: T[]) => K) {
  return array.reduce((result, value, index, array) => {
    const key = iteratee(value, index, array);
    const group = result.get(key);
    if (group) {
      group.push(value);
    } else {
      result.set(key, [value]);
    }

forivall

import { UnionToIntersection } from 'type-fest';

export type ExclusifyUnion<T> = ExclusifyUnion_<T, T>;
type ExclusifyUnion_<T, U> = T extends never
  ? never
  : T & EmptyDifference<T, Exclude<U, T>>; // eslint-disable-line @typescript-eslint/sort-type-constituents
type EmptyDifference<T, U> = Omit<
  UnionToIntersection<T extends never ? never : { [K in keyof U]?: never }>,
  keyof T
>;

forivall

interface AsyncCompose {
  <Options, R1, R2, R3>(
    f: (options: Options) => R1,
    g: (arg: Awaited<R1>, options: Options) => R2,
    h: (arg: Awaited<R2>, options: Options) => R3,
  ): (options: Options) => R2;
  <R1, R2>(f: () => R1, g: (arg: Awaited<R1>) => R2): () => R2;
  <Options, R1, R2>(
    f: (options: Options) => R1,
    g: (arg: Awaited<R1>, options: Options) => R2,

forivall

async function main() {
  console.log('main');
}

(async function () {
  if ('undefined' !== typeof module) {
    return require.main === module && main();
  }
  // eslint-disable-next-line no-new-func
  const meta: ImportMeta = new Function('import.meta')();

forivall

const unit = <T>(value: T) => () => value;
const lazy = <T>(fn: () => T) => {
  let f = (): T => (f = unit(fn()))();
  return () => f();
};

const lazyWithReset = <T>(fn: () => T) => {
  let f: () => T;
  const reset = () => {
    f = () => (f = unit(fn()))();