sebinsua’s gists

sebinsua / withSwr.ts

Last active April 16, 2025 00:05

withSwr.ts

	// Sentinel values
	const REVALIDATING = Symbol.for("@@withSwr/REVALIDATING");
	const READ_ERROR = Symbol.for("@@withSwr/READ_ERROR");
	const INITIAL_READ_ERROR = Symbol.for("@@withSwr/INITIAL_READ_ERROR");

	// Control signals
	const RESET_INITIAL_READ = Symbol.for("@@withSwr/RESET_INITIAL_READ");
	const FINISH_INITIAL_READ = Symbol.for("@@withSwr/FINISH_INITIAL_READ");
	const REVALIDATE = Symbol.for("@@withSwr/REVALIDATE");
	const RESET = RESET_INITIAL_READ;

sebinsua / volumebar.ts

Created November 4, 2024 22:39

	import React, { useEffect, useRef, useState } from 'react';

	class VolumeGenerator {
	public name: string;
	private volume: number;
	private delta: number;

	constructor(name: string, initialVolume = 50) {
	this.name = name;
	this.volume = initialVolume;

sebinsua / crossorigin.plugin.ts

Created September 18, 2024 09:07

crossorigin.plugin.ts

	import type { Plugin, UserConfig } from 'vite';

	type CrossOriginValue = 'anonymous' \| 'use-credentials' \| '';

	interface CrossOriginPluginOptions {
	/**
	* The value to set for the crossorigin attribute.
	* @default 'use-credentials'
	*/
	crossOriginValue?: CrossOriginValue;

sebinsua / smooth-with-array.ts

Last active March 11, 2024 12:02

Smooth a stream of LLM tokens into a stream of characters while reducing jitter by stabilising output timing. Explorations of different approaches.

	function sleep(ms: number) {
	return new Promise((resolve) => setTimeout(resolve, ms));
	}

	class AsyncQueue<T> {
	queuedItems: (T \| Error)[];
	queuedProcessors: [(item: T) => void, (error: Error) => void][];

	constructor() {
	// Note: The FIFO `shift` operations we do on these arrays are `O(n)`.

sebinsua / follow.py

Last active August 23, 2023 21:37

An implementation of a sequential generator called `follow` for traversing linked lists and other data structures in a fixed manner.

	from operator import eq, attrgetter as attr
	from typing import TypeVar, Callable, Iterator, Optional

	eq_or_none = lambda x, y: y is None or eq(x, y)

	T = TypeVar('T')

	def follow(start: T, next_fn: Callable[[T], T], stop: Callable[[T, T], bool] = eq_or_none) -> Iterator[Optional[T]]:
	yield start

sebinsua / in-place-iterative-quicksort.ts

Last active August 16, 2023 16:12

Quicksort

	type Slice = [lowIndex: number, highIndex: number];

	function getRandomIntegerInRange([low, high]: Slice): number {
	return Math.floor(Math.random() * (high - low + 1)) + low;
	}

	function createPartitionForSlice([lowIndex, highIndex]: Slice) {
	return function partition(pivotIndex: number, items: number[]): number {
	// Partitioning a slice works like so:
	// - We get the pivot value from the pivot index (in our case, a random index

sebinsua / interesting-trie.ts

Last active August 9, 2023 16:27

I experimented a little bit with tries.

	export class TrieNode {
	public children: Record<string, TrieNode> = {};
	public isEndOfWord = false;
	}

	export class Trie {
	private root: TrieNode;

	constructor() {
	this.root = new TrieNode();

sebinsua / search-in-rotated-sorted-array.py

Last active November 15, 2023 17:56

Search In Rotated Sorted Array: https://leetcode.com/problems/search-in-rotated-sorted-array/description/

	class Solution:
	def search(self, nums: List[int], target: int) -> int:
	# Special case for lists with only one or two elements.
	if len(nums) <= 2:
	try:
	return nums.index(target)
	except:
	return -1

	# As the array has been sorted and then rotated, it's not actually

sebinsua / find-minimum-in-rotated-sorted-array.py

Created July 25, 2023 13:02

Find Minimum in Rotated Sorted Array: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/

	class Solution:
	def findMin(self, nums: List[int]) -> int:
	# Special case for lists with only two elements.
	if len(nums) == 2:
	return min(*nums)

	# As the array has been sorted and then rotated, it's not actually correctly
	# sorted and we can't use a binary search in the conventional way. However,
	# because we're able to make definitive decisions on which side the minimum
	# value will be found at on every iteration we're still able to use binary

sebinsua / typesafe-zip-2.ts

Last active August 22, 2023 09:29

See previous: https://gist.github.com/sebinsua/e756554faaa2d346aff0341374ee792e

	type Zipped<A extends readonly (readonly any[])[]> = {
	[RowIndex in keyof A[0]]: RowIndex extends "length" ? number : {
	[ArrayIndex in keyof A]: A[ArrayIndex] extends readonly any[] ? A[ArrayIndex][RowIndex] : never;
	};
	};

	type NumericRange<TotalLength extends number, TempRange extends any[] = []> =
	TempRange['length'] extends TotalLength ? TempRange : NumericRange<TotalLength, [...TempRange, TempRange['length']]>;

	type TupleFromKeys<T, K extends readonly (keyof T)[]> = {

Seb Insua sebinsua