saeeol 1.3.0 → 1.3.1

package/test/keybind.test.ts

@@ -0,0 +1,421 @@
+import { describe, test, expect } from "bun:test"
+import { Keybind } from "@/util/keybind"
+
+describe("Keybind.toString", () => {
+  test("should convert simple key to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f" }
+    expect(Keybind.toString(info)).toBe("f")
+  })
+
+  test("should convert ctrl modifier to string", () => {
+    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    expect(Keybind.toString(info)).toBe("ctrl+x")
+  })
+
+  test("should convert leader key to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
+    expect(Keybind.toString(info)).toBe("<leader> f")
+  })
+
+  test("should convert multiple modifiers to string", () => {
+    const info: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
+    expect(Keybind.toString(info)).toBe("ctrl+alt+g")
+  })
+
+  test("should convert all modifiers to string", () => {
+    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: true, name: "h" }
+    expect(Keybind.toString(info)).toBe("<leader> ctrl+alt+shift+h")
+  })
+
+  test("should convert shift modifier to string", () => {
+    const info: Keybind.Info = {
+      ctrl: false,
+      meta: false,
+      shift: true,
+      leader: false,
+      name: "return",
+    }
+    expect(Keybind.toString(info)).toBe("shift+return")
+  })
+
+  test("should convert function key to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f2" }
+    expect(Keybind.toString(info)).toBe("f2")
+  })
+
+  test("should convert special key to string", () => {
+    const info: Keybind.Info = {
+      ctrl: false,
+      meta: false,
+      shift: false,
+      leader: false,
+      name: "pgup",
+    }
+    expect(Keybind.toString(info)).toBe("pgup")
+  })
+
+  test("should handle empty name", () => {
+    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "" }
+    expect(Keybind.toString(info)).toBe("ctrl")
+  })
+
+  test("should handle only modifiers", () => {
+    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: true, name: "" }
+    expect(Keybind.toString(info)).toBe("<leader> ctrl+alt+shift")
+  })
+
+  test("should handle only leader with no other parts", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "" }
+    expect(Keybind.toString(info)).toBe("<leader>")
+  })
+
+  test("should convert super modifier to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
+    expect(Keybind.toString(info)).toBe("super+z")
+  })
+
+  test("should convert super+shift modifier to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
+    expect(Keybind.toString(info)).toBe("super+shift+z")
+  })
+
+  test("should handle super with ctrl modifier", () => {
+    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, super: true, leader: false, name: "a" }
+    expect(Keybind.toString(info)).toBe("ctrl+super+a")
+  })
+
+  test("should handle super with all modifiers", () => {
+    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, super: true, leader: false, name: "x" }
+    expect(Keybind.toString(info)).toBe("ctrl+alt+super+shift+x")
+  })
+
+  test("should handle undefined super field (omitted)", () => {
+    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "c" }
+    expect(Keybind.toString(info)).toBe("ctrl+c")
+  })
+})
+
+describe("Keybind.match", () => {
+  test("should match identical keybinds", () => {
+    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match different key names", () => {
+    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "y" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should not match different modifiers", () => {
+    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "x" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should match leader keybinds", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match leader vs non-leader", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should match complex keybinds", () => {
+    const a: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
+    const b: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match with one modifier different", () => {
+    const a: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
+    const b: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: false, name: "g" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should match simple key without modifiers", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "a" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "a" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should match super modifier keybinds", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match super vs non-super", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, super: false, leader: false, name: "z" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should match undefined super with false super", () => {
+    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "c" }
+    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, super: false, leader: false, name: "c" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should match super+shift combination", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match when only super differs", () => {
+    const a: Keybind.Info = { ctrl: true, meta: true, shift: true, super: true, leader: false, name: "a" }
+    const b: Keybind.Info = { ctrl: true, meta: true, shift: true, super: false, leader: false, name: "a" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+})
+
+describe("Keybind.parse", () => {
+  test("should parse simple key", () => {
+    const result = Keybind.parse("f")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "f",
+      },
+    ])
+  })
+
+  test("should parse leader key syntax", () => {
+    const result = Keybind.parse("<leader>f")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: true,
+        name: "f",
+      },
+    ])
+  })
+
+  test("should parse ctrl modifier", () => {
+    const result = Keybind.parse("ctrl+x")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "x",
+      },
+    ])
+  })
+
+  test("should parse multiple modifiers", () => {
+    const result = Keybind.parse("ctrl+alt+u")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: true,
+        shift: false,
+        leader: false,
+        name: "u",
+      },
+    ])
+  })
+
+  test("should parse shift modifier", () => {
+    const result = Keybind.parse("shift+f2")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: true,
+        leader: false,
+        name: "f2",
+      },
+    ])
+  })
+
+  test("should parse meta/alt modifier", () => {
+    const result = Keybind.parse("meta+g")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: true,
+        shift: false,
+        leader: false,
+        name: "g",
+      },
+    ])
+  })
+
+  test("should parse leader with modifier", () => {
+    const result = Keybind.parse("<leader>h")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: true,
+        name: "h",
+      },
+    ])
+  })
+
+  test("should parse multiple keybinds separated by comma", () => {
+    const result = Keybind.parse("ctrl+c,<leader>q")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "c",
+      },
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: true,
+        name: "q",
+      },
+    ])
+  })
+
+  test("should parse shift+return combination", () => {
+    const result = Keybind.parse("shift+return")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: true,
+        leader: false,
+        name: "return",
+      },
+    ])
+  })
+
+  test("should parse ctrl+j combination", () => {
+    const result = Keybind.parse("ctrl+j")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "j",
+      },
+    ])
+  })
+
+  test("should handle 'none' value", () => {
+    const result = Keybind.parse("none")
+    expect(result).toEqual([])
+  })
+
+  test("should handle special keys", () => {
+    const result = Keybind.parse("pgup")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "pgup",
+      },
+    ])
+  })
+
+  test("should handle function keys", () => {
+    const result = Keybind.parse("f2")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "f2",
+      },
+    ])
+  })
+
+  test("should handle complex multi-modifier combination", () => {
+    const result = Keybind.parse("ctrl+alt+g")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: true,
+        shift: false,
+        leader: false,
+        name: "g",
+      },
+    ])
+  })
+
+  test("should be case insensitive", () => {
+    const result = Keybind.parse("CTRL+X")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "x",
+      },
+    ])
+  })
+
+  test("should parse super modifier", () => {
+    const result = Keybind.parse("super+z")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        super: true,
+        leader: false,
+        name: "z",
+      },
+    ])
+  })
+
+  test("should parse super with shift modifier", () => {
+    const result = Keybind.parse("super+shift+z")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: true,
+        super: true,
+        leader: false,
+        name: "z",
+      },
+    ])
+  })
+
+  test("should parse multiple keybinds with super", () => {
+    const result = Keybind.parse("ctrl+-,super+z")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "-",
+      },
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        super: true,
+        leader: false,
+        name: "z",
+      },
+    ])
+  })
+})

package/test/lib/effect.ts

@@ -0,0 +1,53 @@
+import { test, type TestOptions } from "bun:test"
+import { Cause, Effect, Exit, Layer } from "effect"
+import type * as Scope from "effect/Scope"
+import * as TestClock from "effect/testing/TestClock"
+import * as TestConsole from "effect/testing/TestConsole"
+
+type Body<A, E, R> = Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>)
+
+const body = <A, E, R>(value: Body<A, E, R>) => Effect.suspend(() => (typeof value === "function" ? value() : value))
+
+const run = <A, E, R, E2>(value: Body<A, E, R | Scope.Scope>, layer: Layer.Layer<R, E2>) =>
+  Effect.gen(function* () {
+    const exit = yield* body(value).pipe(Effect.scoped, Effect.provide(layer), Effect.exit)
+    if (Exit.isFailure(exit)) {
+      for (const err of Cause.prettyErrors(exit.cause)) {
+        yield* Effect.logError(err)
+      }
+    }
+    return yield* exit
+  }).pipe(Effect.runPromise)
+
+const make = <R, E>(testLayer: Layer.Layer<R, E>, liveLayer: Layer.Layer<R, E>) => {
+  const effect = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test(name, () => run(value, testLayer), opts)
+
+  effect.only = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test.only(name, () => run(value, testLayer), opts)
+
+  effect.skip = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test.skip(name, () => run(value, testLayer), opts)
+
+  const live = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test(name, () => run(value, liveLayer), opts)
+
+  live.only = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test.only(name, () => run(value, liveLayer), opts)
+
+  live.skip = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
+    test.skip(name, () => run(value, liveLayer), opts)
+
+  return { effect, live }
+}
+
+// Test environment with TestClock and TestConsole
+const testEnv = Layer.mergeAll(TestConsole.layer, TestClock.layer())
+
+// Live environment - uses real clock, but keeps TestConsole for output capture
+const liveEnv = TestConsole.layer
+
+export const it = make(testEnv, liveEnv)
+
+export const testEffect = <R, E>(layer: Layer.Layer<R, E>) =>
+  make(Layer.provideMerge(layer, testEnv), Layer.provideMerge(layer, liveEnv))

package/test/lib/filesystem.ts

@@ -0,0 +1,10 @@
+import path from "path"
+import { Effect, FileSystem } from "effect"
+
+export const writeFileStringScoped = Effect.fn("test.writeFileStringScoped")(function* (file: string, text: string) {
+  const fs = yield* FileSystem.FileSystem
+  yield* fs.makeDirectory(path.dirname(file), { recursive: true })
+  yield* fs.writeFileString(file, text)
+  yield* Effect.addFinalizer(() => fs.remove(file, { force: true }).pipe(Effect.orDie))
+  return file
+})