@bloxystudios/bloxycode 1.0.2 → 1.0.5

package/src/util/rpc.ts

@@ -1,66 +0,0 @@
-export namespace Rpc {
-  type Definition = {
-    [method: string]: (input: any) => any
-  }
-
-  export function listen(rpc: Definition) {
-    onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.request") {
-        const result = await rpc[parsed.method](parsed.input)
-        postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
-      }
-    }
-  }
-
-  export function emit(event: string, data: unknown) {
-    postMessage(JSON.stringify({ type: "rpc.event", event, data }))
-  }
-
-  export function client<T extends Definition>(target: {
-    postMessage: (data: string) => void | null
-    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
-  }) {
-    const pending = new Map<number, (result: any) => void>()
-    const listeners = new Map<string, Set<(data: any) => void>>()
-    let id = 0
-    target.onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.result") {
-        const resolve = pending.get(parsed.id)
-        if (resolve) {
-          resolve(parsed.result)
-          pending.delete(parsed.id)
-        }
-      }
-      if (parsed.type === "rpc.event") {
-        const handlers = listeners.get(parsed.event)
-        if (handlers) {
-          for (const handler of handlers) {
-            handler(parsed.data)
-          }
-        }
-      }
-    }
-    return {
-      call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
-        const requestId = id++
-        return new Promise((resolve) => {
-          pending.set(requestId, resolve)
-          target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
-        })
-      },
-      on<Data>(event: string, handler: (data: Data) => void) {
-        let handlers = listeners.get(event)
-        if (!handlers) {
-          handlers = new Set()
-          listeners.set(event, handlers)
-        }
-        handlers.add(handler)
-        return () => {
-          handlers!.delete(handler)
-        }
-      },
-    }
-  }
-}

package/src/util/scrap.ts

@@ -1,10 +0,0 @@
-export const foo: string = "42"
-export const bar: number = 123
-
-export function dummyFunction(): void {
-  console.log("This is a dummy function")
-}
-
-export function randomHelper(): boolean {
-  return Math.random() > 0.5
-}

package/src/util/signal.ts

@@ -1,12 +0,0 @@
-export function signal() {
-  let resolve: any
-  const promise = new Promise((r) => (resolve = r))
-  return {
-    trigger() {
-      return resolve()
-    },
-    wait() {
-      return promise
-    },
-  }
-}

package/src/util/slug.ts

@@ -1,74 +0,0 @@
-export namespace Slug {
-  const ADJECTIVES = [
-    "brave",
-    "calm",
-    "clever",
-    "cosmic",
-    "crisp",
-    "curious",
-    "eager",
-    "gentle",
-    "glowing",
-    "happy",
-    "hidden",
-    "jolly",
-    "kind",
-    "lucky",
-    "mighty",
-    "misty",
-    "neon",
-    "nimble",
-    "playful",
-    "proud",
-    "quick",
-    "quiet",
-    "shiny",
-    "silent",
-    "stellar",
-    "sunny",
-    "swift",
-    "tidy",
-    "witty",
-  ] as const
-
-  const NOUNS = [
-    "cabin",
-    "cactus",
-    "canyon",
-    "circuit",
-    "comet",
-    "eagle",
-    "engine",
-    "falcon",
-    "forest",
-    "garden",
-    "harbor",
-    "island",
-    "knight",
-    "lagoon",
-    "meadow",
-    "moon",
-    "mountain",
-    "nebula",
-    "orchid",
-    "otter",
-    "panda",
-    "pixel",
-    "planet",
-    "river",
-    "rocket",
-    "sailor",
-    "squid",
-    "star",
-    "tiger",
-    "wizard",
-    "wolf",
-  ] as const
-
-  export function create() {
-    return [
-      ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)],
-      NOUNS[Math.floor(Math.random() * NOUNS.length)],
-    ].join("-")
-  }
-}

package/src/util/timeout.ts

@@ -1,14 +0,0 @@
-export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
-  let timeout: NodeJS.Timeout
-  return Promise.race([
-    promise.then((result) => {
-      clearTimeout(timeout)
-      return result
-    }),
-    new Promise<never>((_, reject) => {
-      timeout = setTimeout(() => {
-        reject(new Error(`Operation timed out after ${ms}ms`))
-      }, ms)
-    }),
-  ])
-}

package/src/util/token.ts

@@ -1,7 +0,0 @@
-export namespace Token {
-  const CHARS_PER_TOKEN = 4
-
-  export function estimate(input: string) {
-    return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
-  }
-}

package/src/util/wildcard.ts

@@ -1,56 +0,0 @@
-import { sortBy, pipe } from "remeda"
-
-export namespace Wildcard {
-  export function match(str: string, pattern: string) {
-    let escaped = pattern
-      .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
-      .replace(/\*/g, ".*") // * becomes .*
-      .replace(/\?/g, ".") // ? becomes .
-
-    // If pattern ends with " *" (space + wildcard), make the trailing part optional
-    // This allows "ls *" to match both "ls" and "ls -la"
-    if (escaped.endsWith(" .*")) {
-      escaped = escaped.slice(0, -3) + "( .*)?"
-    }
-
-    return new RegExp("^" + escaped + "$", "s").test(str)
-  }
-
-  export function all(input: string, patterns: Record<string, any>) {
-    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-    let result = undefined
-    for (const [pattern, value] of sorted) {
-      if (match(input, pattern)) {
-        result = value
-        continue
-      }
-    }
-    return result
-  }
-
-  export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
-    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-    let result = undefined
-    for (const [pattern, value] of sorted) {
-      const parts = pattern.split(/\s+/)
-      if (!match(input.head, parts[0])) continue
-      if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
-        result = value
-        continue
-      }
-    }
-    return result
-  }
-
-  function matchSequence(items: string[], patterns: string[]): boolean {
-    if (patterns.length === 0) return true
-    const [pattern, ...rest] = patterns
-    if (pattern === "*") return matchSequence(items, rest)
-    for (let i = 0; i < items.length; i++) {
-      if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
-        return true
-      }
-    }
-    return false
-  }
-}