monorepo

src/components/embed.tsx

@@ -1,19 +0,0 @@
-import type { ColorResolvable } from "discord.js"
-import type { ReactNode } from "react"
-import * as React from "react"
-
-export type EmbedProps = {
-  color?: ColorResolvable
-  children?: ReactNode
-}
-
-export function Embed(props: EmbedProps) {
-  return (
-    <reacord-element
-      modifyOptions={(options) => {
-        options.embeds ??= []
-        options.embeds.push({ color: props.color })
-      }}
-    />
-  )
-}

src/container.ts

@@ -1,79 +0,0 @@
-import type { Message, MessageOptions, TextBasedChannels } from "discord.js"
-import type { ReacordElement } from "./element.js"
-
-type Action =
-  | { type: "updateMessage"; options: MessageOptions }
-  | { type: "deleteMessage" }
-
-export class ReacordContainer {
-  private channel: TextBasedChannels
-  private message?: Message
-  private actions: Action[] = []
-  private runningPromise?: Promise<void>
-
-  constructor(channel: TextBasedChannels) {
-    this.channel = channel
-  }
-
-  render(instances: ReacordElement[]) {
-    const messageOptions: MessageOptions = {
-      content: instances.join("") || undefined, // empty strings are not allowed
-    }
-
-    const hasContent = messageOptions.content !== undefined
-
-    this.addAction(
-      hasContent
-        ? { type: "updateMessage", options: messageOptions }
-        : { type: "deleteMessage" },
-    )
-  }
-
-  completion() {
-    return this.runningPromise ?? Promise.resolve()
-  }
-
-  private addAction(action: Action) {
-    const lastAction = this.actions[this.actions.length - 1]
-    if (lastAction?.type === action.type) {
-      this.actions[this.actions.length - 1] = action
-    } else {
-      this.actions.push(action)
-    }
-    this.runActions()
-  }
-
-  private runActions() {
-    if (this.runningPromise) return
-
-    this.runningPromise = new Promise((resolve) => {
-      // using a microtask to allow multiple actions to be added synchronously
-      queueMicrotask(async () => {
-        let action: Action | undefined
-        while ((action = this.actions.shift())) {
-          try {
-            await this.runAction(action)
-          } catch (error) {
-            console.error(`Failed to run action:`, action)
-            console.error(error)
-          }
-        }
-        resolve()
-        this.runningPromise = undefined
-      })
-    })
-  }
-
-  private async runAction(action: Action) {
-    if (action.type === "updateMessage") {
-      this.message = await (this.message
-        ? this.message.edit(action.options)
-        : this.channel.send(action.options))
-    }
-
-    if (action.type === "deleteMessage") {
-      await this.message?.delete()
-      this.message = undefined
-    }
-  }
-}

src/element.ts

@@ -1,15 +0,0 @@
-import type { MessageOptions } from "discord.js"
-
-export type ReacordElementJsxTag = "reacord-element"
-
-export type ReacordElement = {
-  modifyOptions: (options: MessageOptions) => void
-}
-
-declare global {
-  namespace JSX {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-    interface IntrinsicElements
-      extends Record<ReacordElementJsxTag, ReacordElement> {}
-  }
-}

src/helpers/deferred.test.ts

@@ -1,14 +0,0 @@
-import test from "ava"
-import { createDeferred } from "./deferred.js"
-
-test("resolve", async (t) => {
-  const deferred = createDeferred<string>()
-  setTimeout(() => deferred.resolve("hi"))
-  t.is(await deferred, "hi")
-})
-
-test("reject", async (t) => {
-  const deferred = createDeferred()
-  setTimeout(() => deferred.reject(new Error("oops")))
-  await t.throwsAsync(() => deferred, { instanceOf: Error, message: "oops" })
-})

src/helpers/deferred.ts

@@ -1,21 +0,0 @@
-// eslint-disable-next-line import/no-unused-modules
-export type Deferred<T> = PromiseLike<T> & {
-  resolve: (value: T | PromiseLike<T>) => void
-  reject: (reason?: unknown) => void
-}
-
-export function createDeferred<T = void>(): Deferred<T> {
-  let resolve: (value: T | PromiseLike<T>) => void
-  let reject: (reason?: unknown) => void
-
-  const promise = new Promise<T>((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-
-  return {
-    then: promise.then.bind(promise),
-    resolve: (value) => resolve(value),
-    reject: (reason) => reject(reason),
-  }
-}

src/helpers/raise.ts

@@ -1,5 +0,0 @@
-import { toError } from "./to-error.js"
-
-export function raise(error: unknown): never {
-  throw toError(error)
-}

src/helpers/reject-after.ts

@@ -1,10 +0,0 @@
-import { setTimeout } from "node:timers/promises"
-import { toError } from "./to-error.js"
-
-export async function rejectAfter(
-  timeMs: number,
-  error: unknown = `rejected after ${timeMs}ms`,
-): Promise<never> {
-  await setTimeout(timeMs)
-  return Promise.reject(toError(error))
-}

src/helpers/to-error.ts

@@ -1,3 +0,0 @@
-export function toError(value: unknown) {
-  return value instanceof Error ? value : new Error(String(value))
-}

src/helpers/types.ts

@@ -1 +0,0 @@
-export type MaybePromise<T> = T | Promise<T>

src/helpers/wait-for-with-timeout.ts

@@ -1,11 +0,0 @@
-import { rejectAfter } from "./reject-after.js"
-import type { MaybePromise } from "./types.js"
-import { waitFor } from "./wait-for.js"
-
-export function waitForWithTimeout(
-  condition: () => MaybePromise<boolean>,
-  timeout = 1000,
-  errorMessage = `timed out after ${timeout}ms`,
-) {
-  return Promise.race([waitFor(condition), rejectAfter(timeout, errorMessage)])
-}

src/helpers/wait-for.ts

@@ -1,8 +0,0 @@
-import { setTimeout } from "node:timers/promises"
-import type { MaybePromise } from "./types.js"
-
-export async function waitFor(condition: () => MaybePromise<boolean>) {
-  while (!(await condition())) {
-    await setTimeout(100)
-  }
-}

src/instance.ts

@@ -1,25 +0,0 @@
-import type { Message, TextBasedChannels } from "discord.js"
-
-export class ReacordInstance {
-  message?: Message
-  content: string
-
-  constructor(content: string) {
-    this.content = content
-  }
-
-  render(channel: TextBasedChannels) {
-    if (this.message) {
-      this.message.edit(this.content).catch(console.error)
-    } else {
-      channel.send(this.content).then((message) => {
-        this.message = message
-      }, console.error)
-    }
-  }
-
-  destroy() {
-    this.message?.delete().catch(console.error)
-    this.message?.channel.messages.cache.delete(this.message?.id)
-  }
-}

src/main.ts

@@ -1 +0,0 @@
-export * from "./root.js"

src/reconciler.ts

@@ -1,94 +0,0 @@
-/* eslint-disable unicorn/no-null */
-import ReactReconciler from "react-reconciler"
-import type { ReacordContainer } from "./container.js"
-import type { ReacordElement, ReacordElementJsxTag } from "./element.js"
-import { raise } from "./helpers/raise.js"
-
-export const reconciler = ReactReconciler<
-  ReacordElementJsxTag,
-  ReacordElement,
-  ReacordContainer,
-  ReacordElement,
-  string,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown
->({
-  now: Date.now,
-  isPrimaryRenderer: true,
-  supportsMutation: false,
-  supportsPersistence: true,
-  supportsHydration: false,
-  scheduleTimeout: setTimeout,
-  cancelTimeout: clearTimeout,
-  noTimeout: -1,
-
-  getRootHostContext: () => ({}),
-  getChildHostContext: () => ({}),
-  shouldSetTextContent: () => false,
-
-  createInstance: (
-    type,
-    props,
-    rootContainerInstance,
-    hostContext,
-    internalInstanceHandle,
-  ) => {
-    return props
-  },
-
-  createTextInstance: (
-    text,
-    rootContainerInstance,
-    hostContext,
-    internalInstanceHandle,
-  ) => {
-    return text
-  },
-
-  prepareForCommit: () => null,
-  resetAfterCommit: () => null,
-
-  appendInitialChild: (parent, child) => raise("Not implemented"),
-  finalizeInitialChildren: (...args) => {
-    console.log("finalizeInitialChildren", args)
-    return false
-  },
-  getPublicInstance: () => raise("Not implemented"),
-  prepareUpdate: () => raise("Not implemented"),
-  preparePortalMount: () => raise("Not implemented"),
-
-  createContainerChildSet: (): ReacordElement[] => {
-    // console.log("createContainerChildSet", [container])
-    return []
-  },
-
-  appendChildToContainerChildSet: (
-    children: ReacordElement[],
-    child: ReacordElement,
-  ) => {
-    // console.log("appendChildToContainerChildSet", [children, child])
-    children.push(child)
-  },
-
-  finalizeContainerChildren: (
-    container: ReacordContainer,
-    children: ReacordElement[],
-  ) => {
-    // console.log("finalizeContainerChildren", [container, children])
-    return false
-  },
-
-  replaceContainerChildren: (
-    container: ReacordContainer,
-    children: ReacordElement[],
-  ) => {
-    console.log("replaceContainerChildren", [container, children])
-    container.render(children)
-  },
-})

src/root.ts

@@ -1,23 +0,0 @@
-/* eslint-disable unicorn/no-null */
-import type { TextBasedChannels } from "discord.js"
-import type { ReactNode } from "react"
-import { ReacordContainer } from "./container"
-import { reconciler } from "./reconciler"
-
-export type ReacordRenderTarget = TextBasedChannels
-
-export function createRoot(target: ReacordRenderTarget) {
-  const container = new ReacordContainer(target)
-  const containerId = reconciler.createContainer(container, 0, false, null)
-  return {
-    render: (content: ReactNode) => {
-      reconciler.updateContainer(content, containerId)
-      return container.completion()
-    },
-    destroy: () => {
-      reconciler.updateContainer(null, containerId)
-      return container.completion()
-    },
-    completion: () => container.completion(),
-  }
-}