@davidsouther/jiffies 2026.24.0 → 2026.24.2

package/src/fs.ts

@@ -1,300 +0,0 @@
-import { assertExists } from "./assert.ts";
-
-// Treat localstorage as a file system
-export type PathLike = string;
-
-export interface PlatformParts {
-  SEP: string;
-  WD: string;
-  isAbsolute(path: PathLike): boolean;
-}
-
-export const PLATFORM_PARTS_WIN: PlatformParts = {
-  SEP: "\\",
-  WD: "C:\\\\",
-  isAbsolute: (path) => Boolean(path.match(/^[a-zA-Z]:\\/)),
-};
-
-export const PLATFORM_PARTS_UNIX: PlatformParts = {
-  SEP: "/",
-  WD: "/",
-  isAbsolute: (path) => path[0] === "/",
-};
-
-export const PLATFORM_PARTS: PlatformParts =
-  typeof process !== "undefined" && process.platform === "win32"
-    ? PLATFORM_PARTS_WIN
-    : PLATFORM_PARTS_UNIX;
-
-export const SEP = PLATFORM_PARTS.SEP;
-export const WD = PLATFORM_PARTS.WD;
-export const isAbsolute = PLATFORM_PARTS.isAbsolute;
-
-// Compatible with Node's fs.Dirent
-export interface Stats {
-  isDirectory(): boolean;
-  isFile(): boolean;
-  name: string;
-}
-
-export function basename(filename: PathLike): string {
-  if (filename.endsWith(SEP)) {
-    filename = filename.substring(0, filename.length - 1);
-  }
-  const basename = filename.split(SEP).at(-1) ?? "";
-  return basename;
-}
-
-function join(...paths: string[]): string {
-  const pathParts: string[] = [];
-  for (const path of paths) {
-    for (const part of path.split(SEP)) {
-      switch (part) {
-        case "":
-        case ".":
-          break;
-        case "..":
-          pathParts.pop();
-          break;
-        default:
-          pathParts.push(part);
-      }
-    }
-  }
-  return (
-    (PLATFORM_PARTS === PLATFORM_PARTS_UNIX ? SEP : "") + pathParts.join(SEP)
-  );
-}
-
-export interface FileSystemAdapter {
-  stat(path: PathLike): Promise<Stats>;
-  readdir(path: PathLike): Promise<string[]>;
-  scandir(path: PathLike): Promise<Stats[]>;
-  mkdir(path: PathLike): Promise<void>;
-  copyFile(from: PathLike, to: PathLike): Promise<void>;
-  readFile(path: PathLike): Promise<string>;
-  writeFile(path: PathLike, contents: string): Promise<void>;
-  rm(path: PathLike): Promise<void>;
-}
-
-export class FileSystem implements FileSystemAdapter {
-  protected wd = WD;
-  protected stack: string[] = [];
-  protected adapter: FileSystemAdapter;
-
-  constructor(adapter: FileSystemAdapter = new RecordFileSystemAdapter()) {
-    this.adapter = adapter;
-  }
-
-  cwd(): string {
-    return this.wd;
-  }
-
-  cd(dir: string) {
-    this.wd = this.p(dir);
-  }
-
-  pushd(dir: string) {
-    this.stack.push(this.wd);
-    this.cd(dir);
-  }
-
-  popd() {
-    if (this.stack.length > 0) {
-      this.wd = assertExists(this.stack.pop());
-    }
-  }
-
-  stat(path: PathLike): Promise<Stats> {
-    return this.adapter.stat(this.p(path));
-  }
-
-  scandir(path: PathLike): Promise<Stats[]> {
-    return this.adapter.scandir(this.p(path));
-  }
-
-  readdir(path: PathLike): Promise<string[]> {
-    return this.adapter.readdir(this.p(path));
-  }
-
-  mkdir(path: string): Promise<void> {
-    return this.adapter.mkdir(this.p(path));
-  }
-
-  copyFile(from: PathLike, to: PathLike): Promise<void> {
-    return this.adapter.copyFile(this.p(from), this.p(to));
-  }
-
-  readFile(path: PathLike): Promise<string> {
-    return this.adapter.readFile(this.p(path));
-  }
-
-  writeFile(path: PathLike, contents: string): Promise<void> {
-    return this.adapter.writeFile(this.p(path), contents);
-  }
-
-  rm(path: PathLike): Promise<void> {
-    return this.adapter.rm(this.p(path));
-  }
-
-  private p(path: PathLike): string {
-    return isAbsolute(path) ? path : join(this.cwd(), path);
-  }
-}
-
-export class RecordFileSystemAdapter implements FileSystemAdapter {
-  private fs: Record<string, string>;
-  constructor(fs: Record<string, string> = {}) {
-    this.fs = fs;
-  }
-
-  stat(path: PathLike): Promise<Stats> {
-    return new Promise((resolve, reject) => {
-      if (this.fs[path]) {
-        return resolve({
-          name: basename(path),
-          isDirectory() {
-            return false;
-          },
-          isFile() {
-            return true;
-          },
-        });
-      }
-
-      if (!path.endsWith(SEP)) path += SEP;
-      for (const filename of Object.keys(this.fs)) {
-        if (filename.startsWith(path)) {
-          return resolve({
-            name: basename(path),
-            isDirectory() {
-              return true;
-            },
-            isFile() {
-              return false;
-            },
-          });
-        }
-      }
-
-      reject();
-    });
-  }
-
-  async scandir(path: PathLike): Promise<Stats[]> {
-    return (await this.readdir(path)).map<Stats>((name) => {
-      const isFile = this.fs[join(path, name)] !== undefined;
-      return {
-        name,
-        isDirectory() {
-          return !isFile;
-        },
-        isFile() {
-          return isFile;
-        },
-      };
-    });
-  }
-
-  readdir(path: PathLike): Promise<string[]> {
-    if (!path.endsWith(SEP)) path += SEP;
-    return new Promise((resolve) => {
-      const dir = new Set<string>();
-      for (const filename of Object.keys(this.fs)) {
-        if (filename.startsWith(path)) {
-          const end = filename.indexOf(SEP, path.length + 1);
-          const basename = filename.substring(
-            path.length,
-            end === -1 ? undefined : end,
-          );
-          dir.add(basename);
-        }
-      }
-      return resolve([...dir].sort());
-    });
-  }
-
-  mkdir(_path: string): Promise<void> {
-    return Promise.resolve();
-  }
-
-  copyFile(from: PathLike, to: PathLike): Promise<void> {
-    return new Promise((resolve) => {
-      this.fs[to] = this.fs[from];
-      resolve();
-    });
-  }
-
-  readFile(path: PathLike): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const file = this.fs[path];
-      if (file === undefined) {
-        const error = new Error(`File Not Found ${path}`);
-        reject(error);
-      } else {
-        resolve(file);
-      }
-    });
-  }
-
-  writeFile(path: PathLike, contents: string): Promise<void> {
-    return new Promise((resolve) => {
-      this.fs[path] = contents;
-      resolve();
-    });
-  }
-
-  rm(path: PathLike): Promise<void> {
-    return new Promise((resolve) => {
-      delete this.fs[path];
-      resolve();
-    });
-  }
-}
-
-export class LocalStorageFileSystemAdapter extends RecordFileSystemAdapter {
-  constructor() {
-    super(window.localStorage);
-  }
-}
-
-export type ObjectFileSystem = { [k: string]: string | ObjectFileSystem };
-export class ObjectFileSystemAdapter extends RecordFileSystemAdapter {
-  constructor(object: ObjectFileSystem) {
-    super(reduceObjectFileSystem(object));
-  }
-}
-
-function reduceObjectFileSystem(
-  object: ObjectFileSystem,
-): Record<string, string> {
-  const level: Record<string, string> = {};
-
-  for (const [k, v] of Object.entries(object)) {
-    if (typeof v === "string") {
-      level[`/${k}`] = v;
-    } else {
-      for (const [k2, v2] of Object.entries(reduceObjectFileSystem(v))) {
-        level[`/${k}${k2}`] = v2;
-      }
-    }
-  }
-
-  return level;
-}
-
-export interface Tree {
-  [k: string]: string | Tree;
-}
-
-export async function reset(fs: FileSystem, tree: Tree): Promise<void> {
-  for (const [path, file] of Object.entries(tree)) {
-    if (typeof file === "string") {
-      await fs.writeFile(path, file);
-    } else {
-      fs.cd(path);
-      await reset(fs, file);
-      fs.cd("..");
-    }
-  }
-}

package/src/fs_node.ts

@@ -1,57 +0,0 @@
-import {
-  copyFile,
-  mkdir,
-  readdir,
-  readFile,
-  rm,
-  stat,
-  writeFile,
-} from "node:fs/promises";
-import { basename, join } from "node:path";
-import { FileSystem, type FileSystemAdapter, type Stats } from "./fs.ts";
-
-export class NodeFileSystem extends FileSystem {
-  constructor(cd: string = process.cwd()) {
-    super(new NodeFileSystemAdapter());
-    this.cd(cd);
-  }
-}
-
-/** Jiffies FileSystemAdapter using NodeJS' fs/promises. */
-export class NodeFileSystemAdapter implements FileSystemAdapter {
-  async stat(path: string): Promise<Stats> {
-    const fsStat = await stat(path);
-    return {
-      name: basename(path),
-      isDirectory() {
-        return fsStat.isDirectory();
-      },
-      isFile() {
-        return !fsStat.isDirectory();
-      },
-    };
-  }
-  readdir(path: string): Promise<string[]> {
-    return readdir(path);
-  }
-  async mkdir(path: string): Promise<void> {
-    await mkdir(path, { recursive: true });
-  }
-  async scandir(path: string): Promise<Stats[]> {
-    return Promise.all(
-      (await this.readdir(path)).map((name) => this.stat(join(path, name))),
-    );
-  }
-  copyFile(from: string, to: string): Promise<void> {
-    return copyFile(from, to);
-  }
-  readFile(path: string): Promise<string> {
-    return readFile(path, "utf-8");
-  }
-  writeFile(path: string, contents: string): Promise<void> {
-    return writeFile(path, contents, "utf-8");
-  }
-  rm(path: string): Promise<void> {
-    return rm(path, { force: true, recursive: true });
-  }
-}

package/src/generator.ts

@@ -1,12 +0,0 @@
-export function* takeWhile<T>(
-  predicate: (t: T) => boolean,
-  iterator: Iterable<T>,
-) {
-  for (const x of iterator) {
-    if (predicate(x)) {
-      yield x;
-    } else {
-      return;
-    }
-  }
-}

package/src/hooks/_notes

@@ -1,6 +0,0 @@
-useEffect
-useState
-useContext
-
-
-signal(n) => n, setN

package/src/lock.ts

@@ -1,23 +0,0 @@
-const locks = new WeakSet<CallableFunction>();
-
-export function lock<CF extends (...args: unknown[]) => unknown>(fn: CF): CF {
-  const lockingFn = (...args: unknown[]): ReturnType<CF> => {
-    let ret: ReturnType<CF>;
-    let ex = null;
-    if (!locks.has(fn)) {
-      locks.add(fn);
-      try {
-        ret = fn(...args) as ReturnType<CF>;
-      } catch (e) {
-        ex = e;
-      }
-    }
-    locks.delete(fn);
-    if (ex !== null) {
-      throw ex;
-    }
-    // @ts-expect-error 2454 can't track ret's assignment
-    return ret;
-  };
-  return lockingFn as CF;
-}

package/src/log.ts

@@ -1,307 +0,0 @@
-import { type Display, display } from "./display.ts";
-
-export type Log = (message: Display, data?: object) => void;
-
-export interface Logger {
-  logAt: (level: number, prefix: string, fn?: (logLine: string) => void) => Log;
-  level: number;
-  format: <
-    D extends {
-      name: string;
-      prefix: string;
-      level: number;
-      message: string;
-      source: string;
-    },
-  >(
-    data: D,
-  ) => string;
-  console: Console;
-  default: (logLine: string) => void;
-  debug: Log;
-  info: Log;
-  warn: Log;
-  error: Log;
-}
-
-export const LEVEL = {
-  UNKNOWN: 2,
-  DEBUG: 1,
-  VERBOSE: 1,
-  INFO: 2,
-  WARN: 3,
-  ERROR: 4,
-  SILENT: 5,
-};
-
-export const LEVELS: Record<string, number> = {
-  unknown: LEVEL.UNKNOWN,
-  debug: LEVEL.DEBUG,
-  verbose: LEVEL.VERBOSE,
-  info: LEVEL.INFO,
-  warn: LEVEL.WARN,
-  error: LEVEL.ERROR,
-  silent: LEVEL.SILENT,
-};
-
-export function getLogLevel(level = ""): number {
-  return (
-    LEVELS[level.toLowerCase()] ??
-    (!Number.isNaN(+level) ? Number(level) : LEVEL.INFO)
-  );
-}
-
-export function basicLogFormatter(data: {
-  name: string;
-  prefix: string;
-  level: number;
-  message: string;
-  source: string;
-}): string {
-  return `${data.prefix}: ${data.message}`;
-}
-
-function findSource() {
-  const err = new Error();
-  // Stack will be:
-  // findSource
-  // logAt
-  // {source}
-  const lines = err.stack?.split("\n") ?? [];
-  const atLines = lines.filter((line) => line.match(/^\s*at/));
-  return atLines[2]?.trim().slice("at ".length) ?? "(unknown)";
-}
-
-export type LoggerFormatFn = <
-  D extends {
-    name: string;
-    prefix: string;
-    level: number;
-    message: string;
-    source: string;
-  },
->(
-  data: D,
-) => string;
-
-// ── prettyLogFormatter ──────────────────────────────────────────────────────
-// A TTY-aware formatter: compact, color-and-glyph-coded human lines on a
-// terminal, byte-identical JSON.stringify when piped/redirected so machine
-// tooling is unchanged. See docs/developer/2026-06-09-A-log-formatter/design.md.
-
-// Raw ANSI escapes; no color/log runtime dependency in this library.
-const ANSI = {
-  reset: "\x1b[0m",
-  dim: "\x1b[2m",
-  bold: "\x1b[1m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  red: "\x1b[31m",
-  cyan: "\x1b[36m",
-  white: "\x1b[37m",
-} as const;
-type AnsiCode = keyof typeof ANSI;
-
-// HH:MM:SS.mmm sliced from a UTC ISO 8601 string. Timezone-stable by
-// construction: it never reads local-time accessors, so output depends only on
-// the ISO input, not the runner's TZ.
-function shortClock(iso: string): string {
-  return iso.slice(11, 23);
-}
-
-// Glyph + color per severity, keyed on the numeric level (DEBUG 1, INFO 2,
-// WARN 3, ERROR 4). Fixed single-column glyph so messages align vertically.
-function levelGlyph(level: number): { glyph: string; color: AnsiCode } {
-  if (level <= LEVEL.DEBUG) return { glyph: "·", color: "dim" };
-  if (level === LEVEL.INFO) return { glyph: "ℹ", color: "green" };
-  if (level === LEVEL.WARN) return { glyph: "⚠", color: "yellow" };
-  return { glyph: "✖", color: "red" };
-}
-
-function methodColor(method: string): AnsiCode {
-  switch (method) {
-    case "GET":
-      return "cyan";
-    case "POST":
-      return "green";
-    case "PUT":
-    case "PATCH":
-      return "yellow";
-    case "DELETE":
-      return "red";
-    default:
-      return "white";
-  }
-}
-
-function statusColor(status: number): AnsiCode {
-  if (status >= 500) return "red";
-  if (status >= 400) return "yellow";
-  if (status >= 300) return "cyan";
-  return "green";
-}
-
-// Fields that are pure metadata noise on a human terminal: `name`/`level` are
-// constant or duplicate `prefix`, and `source` resolves to the info() wrapper.
-// `message` is rendered on its own, never echoed into the trailing tail.
-const HUMAN_DROP = new Set(["name", "prefix", "level", "source", "message"]);
-
-export interface PrettyLogOptions {
-  /** Render colored, human-shaped lines. Default: !!process.stdout.isTTY. */
-  tty?: boolean;
-  /** Emit ANSI color escapes. Default: same as `tty`. */
-  color?: boolean;
-  /** Injectable clock for deterministic timestamps in tests. Default: new Date. */
-  now?: () => Date;
-}
-
-/**
- * Factory returning a {@link LoggerFormatFn} that is pretty + colored on a TTY
- * and falls back to `JSON.stringify` when not. Options resolve once at
- * construction (`tty` reads `process.stdout.isTTY`), so production piped output
- * stays JSON; tests inject `tty`/`color`/`now` for a deterministic colorless
- * layout assertable without a real terminal.
- */
-export function prettyLogFormatter(
-  options: PrettyLogOptions = {},
-): LoggerFormatFn {
-  const tty = options.tty ?? !!process.stdout.isTTY;
-  const color = options.color ?? tty;
-  const now = options.now ?? (() => new Date());
-  const paint = (code: AnsiCode, s: string): string =>
-    color ? `${ANSI[code]}${s}${ANSI.reset}` : s;
-
-  return <
-    D extends {
-      name: string;
-      prefix: string;
-      level: number;
-      message: string;
-      source: string;
-    },
-  >(
-    data: D,
-  ): string => {
-    if (!tty) return JSON.stringify(data);
-
-    const record = data as unknown as Record<string, unknown>;
-    const { glyph, color: glyphColor } = levelGlyph(data.level);
-    const mark = paint(glyphColor, glyph);
-
-    // Access-log shape: `<glyph> <clock> <METHOD> <path> <client> [status] [ms]`.
-    // Clock comes from the request's `when` ISO (UTC slice), not now().
-    if (data.message === "Request") {
-      const when = typeof record.when === "string" ? record.when : "";
-      const how = typeof record.how === "string" ? record.how : "";
-      const space = how.indexOf(" ");
-      const method = space === -1 ? how : how.slice(0, space);
-      const path = space === -1 ? "" : how.slice(space + 1);
-      const segments = [
-        mark,
-        paint("dim", shortClock(when || now().toISOString())),
-        paint(methodColor(method), method),
-        paint("bold", path),
-      ];
-      if (record.who !== undefined) {
-        segments.push(paint("dim", String(record.who)));
-      }
-      if (record.status !== undefined) {
-        segments.push(
-          paint(statusColor(Number(record.status)), String(record.status)),
-        );
-      }
-      if (record.ms !== undefined) {
-        segments.push(paint("dim", `${record.ms}ms`));
-      }
-      return segments.filter((s) => s !== "").join(" ");
-    }
-
-    // Generic shape: `<glyph> <clock> <message> <dim key=value …>`.
-    const tail = Object.entries(record)
-      .filter(([key]) => !HUMAN_DROP.has(key))
-      .map(([key, value]) =>
-        paint(
-          "dim",
-          `${key}=${typeof value === "string" ? value : JSON.stringify(value)}`,
-        ),
-      );
-    return [
-      mark,
-      paint("dim", shortClock(now().toISOString())),
-      paint("bold", data.message),
-      ...tail,
-    ].join(" ");
-  };
-}
-
-export function getLogger(
-  name: string,
-  args: LoggerFormatFn | { format?: LoggerFormatFn; console?: Console } = {
-    format: JSON.stringify,
-    console,
-  },
-): Logger {
-  if (args instanceof Function) {
-    args = { format: args };
-  }
-  const defaultLog = (logLine: string): void => {
-    logger.console.info(logLine);
-  };
-  const logAt =
-    (
-      level: number,
-      prefix: string,
-      fn: (logLine: string) => void = defaultLog,
-    ): Log =>
-    (message: Display, data?: object) =>
-      level >= (logger.level ?? LEVEL.SILENT)
-        ? fn(
-            logger.format?.({
-              name,
-              prefix,
-              level,
-              message: display(message),
-              ...data,
-              source: findSource(),
-            }),
-          )
-        : undefined;
-
-  const logger: Logger = {
-    logAt,
-    default: defaultLog,
-    level: LEVEL.INFO,
-    format: args.format ?? JSON.stringify,
-    console: args.console ?? global.console,
-    debug: logAt(LEVEL.DEBUG, "DEBUG", (l) => logger.console.debug(l)),
-    info: logAt(LEVEL.INFO, "INFO", (l) => logger.console.info(l)),
-    warn: logAt(LEVEL.WARN, "WARN", (l) => logger.console.warn(l)),
-    error: logAt(LEVEL.ERROR, "ERR", (l) => logger.console.error(l)),
-  };
-
-  return logger as Logger;
-}
-
-export const DEFAULT_LOGGER = getLogger("default", {
-  format: prettyLogFormatter(),
-});
-
-export function debug(message: Display, data?: object) {
-  if (data) DEFAULT_LOGGER.debug(message, data);
-  else DEFAULT_LOGGER.debug(message);
-}
-
-export function info(message: Display, data?: object) {
-  if (data) DEFAULT_LOGGER.info(message, data);
-  else DEFAULT_LOGGER.info(message);
-}
-
-export function warn(message: Display, data?: object) {
-  if (data) DEFAULT_LOGGER.warn(message, data);
-  else DEFAULT_LOGGER.warn(message);
-}
-
-export function error(message: Display, data?: object) {
-  if (data) DEFAULT_LOGGER.error(message, data);
-  else DEFAULT_LOGGER.error(message);
-}