colelawrence

export const OrgResource = RBAC.defineResource({
  name: dev`Organization`,
  idSchema: OrgID,
  permissions: {
    CreateWorkspace: (its) => its.Member,
  },
  roles: {
    Admin: true,
    Member: true,
    Guest: true,

colelawrence

import { DevError, debounce } from "@project/prelude";

export class LoopError extends DevError {
  constructor(
    message: string,
    public readonly debounceMs: number,
    public readonly maxCount: number,
  ) {
    super(`${message} (exceeded ${maxCount} calls in ${(debounceMs * 0.001).toFixed(1)}s)`);
  }

colelawrence

export class MapOrSetDefault<K, T> extends Map<K, T> {
  #setDefault(key: K): T {
    const val = this.getDefault(key);
    this.set(key, val);
    return val;
  }
  constructor(public getDefault: (key: K) => T) {
    super();
  }

colelawrence

export function downloadFileBinary(filename: string, data: Uint8Array, mimeType = "application/octet-stream") {
  const blob = new Blob([data], { type: mimeType });
  const url = URL.createObjectURL(blob);
  const a = document.createElement("a");
  a.href = url;
  a.download = filename;
  a.click();
  URL.revokeObjectURL(url);
}

colelawrence

import { useEffect } from "react";
import { listen } from "./zlisten";

/** For when you want to do something without breaking the focus of the active element */
export const useClickByHoverToAvoidChangingFocus = (element: HTMLElement | null | undefined, callback: null | undefined | (() => void)) => {
  useEffect(() => {
    if (!element || !callback) return;

    let openTimeout: (Animation | any)[] = [];
    const DURATION = 1000;

colelawrence

type Fn<T, U> = (t: T) => U | null | undefined;
/** like pipe, but returns early if any of the functions return a nullish value */
export function pipeNonNull<A, B>(a: A, b: Fn<A, B>): B | null | undefined;
export function pipeNonNull<A, B, C>(a: A, b: Fn<A, B>, c: Fn<B, C>): C | null | undefined;
export function pipeNonNull<A, B, C, D>(a: A, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>): D | null | undefined;
export function pipeNonNull<A, B, C, D, E>(a: A, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>): E | null | undefined;
export function pipeNonNull<A, B, C, D, E, F>(
  a: A,
  b: Fn<A, B>,
  c: Fn<B, C>,

colelawrence

const objectPredicateMacro = <T>(keys: (keyof T | (string & {}))[]): ((obj: unknown) => obj is T) => {
  return new Function(
    "isObject",
    "value",
    `return isObject(value) ${keys.map((key) => `&& ${JSON.stringify(key)} in value`).join(" ")};`,
  ).bind(null, isObject);
};

const isStore = objectPredicateMacro<JotaiStore>(["get", "set", "sub", "unstable_derive"]);

colelawrence

Feature Documentation Guidelines

Feature docs are files in docs/my-idea-feature.md files.

(Product Values)

When considering the details for any given product feature keep in mind our values:

1. Privacy and Security: Prioritize user data protection and system security in all feature designs
2. Transparency: Ensure clear communication of data usage and consent processes

colelawrence

interface listen {
  <K extends keyof HTMLElementEventMap>(
    target: HTMLElement,
    type: K,
    listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void,
    options?: boolean | AddEventListenerOptions,
  ): () => void;
  (
    target: EventTarget,
    type: string,

colelawrence

const INDENTATION_RE = /^\n( +)/;

const unindentTemplate = (
  template: TemplateStringsArray,
): { readonly raw: readonly string[] } => {
  const indentation = INDENTATION_RE.exec(template.raw[0])?.[1];
  return indentation
    ? { raw: template.raw.map((a) => a.replaceAll(`\n${indentation}`, "\n")) }
    : template;
};