houdini-react 2.0.0-go.1 → 2.0.0-go.10

package/runtime/routing/cache.ts

@@ -0,0 +1,52 @@
+// a suspense cache is an object that maintains a key-value store of
+// objects. If a value is missing when get() is called, a promise
+// is thrown that resolves when a value is passed to set()
+import { LRUCache } from 'houdini/runtime'
+
+export function suspense_cache<T>(initialData?: Record<string, T>): SuspenseCache<T> {
+	const cache = new SuspenseCache<T>()
+
+	for (const [key, value] of Object.entries(initialData ?? {})) {
+		cache.set(key, value)
+	}
+
+	return cache
+}
+
+export class SuspenseCache<_Data> extends LRUCache<_Data> {
+	// if get is called before set, we need to invoke a callback.
+	// that means we need a place to put our callbacks
+	#callbacks: Map<string, { resolve: () => void; reject: () => void }[]> = new Map()
+
+	get(key: string): _Data {
+		// if there is a value, use that
+		if (super.has(key)) {
+			return super.get(key)!
+		}
+
+		// we don't have a value, so we need to throw a promise
+		// that resolves when a value is passed to set()
+		throw new Promise<void>((resolve, reject) => {
+			this.#subscribe(key, resolve, reject)
+		})
+	}
+
+	// TODO: reject?
+
+	set(key: string, value: _Data) {
+		// perform the set like normal
+		super.set(key, value)
+
+		// if there are subscribers, resolve them
+		if (this.#callbacks.has(key)) {
+			// resolve all of the callbacks
+			this.#callbacks.get(key)?.forEach(({ resolve }) => resolve())
+			// delete the key
+			this.#callbacks.delete(key)
+		}
+	}
+
+	#subscribe(key: string, resolve: () => void, reject: () => void) {
+		this.#callbacks.set(key, [...(this.#callbacks.get(key) || []), { resolve, reject }])
+	}
+}

package/runtime/routing/index.ts

@@ -0,0 +1,2 @@
+export * from './Router'
+export { type SuspenseCache, suspense_cache } from './cache'

package/server/index.d.ts

@@ -0,0 +1 @@
+export { renderToStream } from 'react-streaming-compat/server';

package/server/index.js

@@ -0,0 +1,4 @@
+import { renderToStream } from "react-streaming-compat/server";
+export {
+  renderToStream
+};

package/server/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/vite/index.d.ts

@@ -0,0 +1,3 @@
+import { VitePluginContext } from 'houdini/vite';
+import { PluginOption } from 'vite';
+export default function (ctx: VitePluginContext): PluginOption;

package/vite/index.js

@@ -0,0 +1,11 @@
+function vite_default(ctx) {
+  return {
+    name: "houdini-react",
+    configureServer(server) {
+      console.log("greetings from react vite plugin");
+    }
+  };
+}
+export {
+  vite_default as default
+};

package/vite/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/shim.cjs

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-
-function getBinaryPath() {
-	// lookup table for all platforms and binary distribution packages
-	const BINARY_DISTRIBUTION_PACKAGES = {
-		'linux-x64': 'houdini-react-linux-x64',
-		'linux-arm64': 'houdini-react-linux-arm64',
-		'win32-x64': 'houdini-react-windows-x64',
-		'win32-arm64': 'houdini-react-windows-arm64',
-		'darwin-x64': 'houdini-react-darwin-x64',
-		'darwin-arm64': 'houdini-react-darwin-arm64',
-	}
-
-	// windows binaries end with .exe so we need to special case them
-	const binaryName = process.platform === 'win32' ? 'houdini-react.exe' : 'houdini-react'
-
-	// determine package name for this platform
-	const platformSpecificPackageName =
-		BINARY_DISTRIBUTION_PACKAGES[`${process.platform}-${process.arch}`]
-
-	try {
-		// resolving will fail if the optionalDependency was not installed
-		return require.resolve(`../${platformSpecificPackageName}/bin/${binaryName}`)
-	} catch (e) {
-		return require('path').join(__dirname, binaryName)
-	}
-}
-// instead of execFileSync, use spawn to handle the process more gracefully
-const childProcess = require('child_process').spawn(getBinaryPath(), process.argv.slice(2), {
-	stdio: 'inherit',
-})
-
-// array of signals we want to handle
-const signals = ['SIGTERM', 'SIGINT', 'SIGQUIT', 'SIGHUP']
-
-// handle each signal
-signals.forEach((signal) => {
-	process.on(signal, () => {
-		if (childProcess) {
-			// on windows, we need to use taskkill for proper tree killing
-			if (process.platform === 'win32') {
-				require('child_process').spawn('taskkill', ['/pid', childProcess.pid, '/f', '/t'])
-			} else {
-				try {
-					childProcess.kill(signal)
-				} catch (err) {
-					// if the process is already gone, that's fine
-					if (err.code !== 'ESRCH') throw err
-				}
-			}
-		}
-		process.exit(0)
-	})
-})
-
-// handle child process exit
-childProcess.on('exit', (code, signal) => {
-	// if the child was terminated due to a signal, exit with the same signal
-	if (signal) {
-		process.exit(0)
-	} else {
-		process.exit(code)
-	}
-})