npm - rsf-zero - Versions diffs - 0.1.0 - Mend

rsf-zero 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/README.md +56 -0
package/dist/cli/build/buildClientFiles.js +26 -0
package/dist/cli/build/buildServerFiles.js +89 -0
package/dist/cli/build.js +12 -0
package/dist/cli/dev/startVite.js +32 -0
package/dist/cli/dev.js +30 -0
package/dist/cli/start/createActionRoute.js +54 -0
package/dist/cli/start.js +34 -0
package/dist/cli.js +19 -0
package/dist/debug.js +5 -0
package/dist/lib/client.js +22 -0
package/dist/transform/asRelativeImport.js +19 -0
package/dist/transform/client/transformRsfForClientPlugin.js +20 -0
package/dist/transform/client/transformTopLevelRsf.js +64 -0
package/dist/transform/collectExportNames.js +25 -0
package/dist/transform/extname.js +10 -0
package/dist/transform/getActionId.js +7 -0
package/dist/transform/isTopLevelRsfFile.js +8 -0
package/dist/transform/replaceFileExt.js +5 -0
package/dist/transform/server/generateActionRegistry.js +60 -0
package/dist/types.js +1 -0
package/package.json +46 -0

package/README.md ADDED Viewed

@@ -0,0 +1,56 @@
+# rsf-zero
+## Setup
+Add these scripts to your **package.json**:
+```
+...
+  "scripts": {
+    "dev": "rsf-zero dev",
+    "build": "rsf-zero build",
+    "start": "rsf-zero start",
+  },
+...
+```
+Then create an **index.html**:
+```html
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RSF-Zero example</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+```
+And finally create a **src/main.tsx** file:
+```tsx
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+createRoot(document.getElementById("root")!).render(
+  <StrictMode>
+    RSF Zero up and running!
+  </StrictMode>,
+);
+```
+## Advanced topics
+### Server function arguments
+Server function calls are serialised and deserialised between client and server. Server function argument types must be serialisable.
+**RSF Zero** uses [superjson](https://github.com/flightcontrolhq/superjson) under the hood, and the most common types are supported.
+See the [superjson docs](https://github.com/flightcontrolhq/superjson?tab=readme-ov-file#parse) for more info.
+### Verbose logging
+Prefix commands with `NODE_DEBUG=rsf-zero` to see debug logs, for example: `NODE_DEBUG=rsf-zero yarn build`.

package/dist/cli/build/buildClientFiles.js ADDED Viewed

@@ -0,0 +1,26 @@
+import path from "path";
+import { build as viteBuild } from "vite";
+import viteReact from "@vitejs/plugin-react";
+import { transformRsfForClientPlugin } from "../../transform/client/transformRsfForClientPlugin.js";
+import { debug } from "../../debug.js";
+export const buildClientFiles = async (rootDir, onActionFound) => {
+    let actionCounter = 0; // for logging
+    const _onActionFound = (action) => {
+        actionCounter++;
+        onActionFound(action);
+    };
+    const clientOutDir = path.join(rootDir, 'dist/client');
+    await viteBuild({
+        mode: 'production',
+        base: '/',
+        plugins: [
+            viteReact(),
+            transformRsfForClientPlugin(_onActionFound),
+        ],
+        build: {
+            emptyOutDir: true,
+            outDir: clientOutDir,
+        },
+    });
+    debug(`Built client with ${actionCounter} actions to ${clientOutDir}.`);
+};

package/dist/cli/build/buildServerFiles.js ADDED Viewed

@@ -0,0 +1,89 @@
+import path from "path";
+import fs from "fs";
+import { createProgram, flattenDiagnosticMessageText, ModuleKind, } from "typescript";
+import md5 from "md5";
+import * as os from "node:os";
+import { generateActionRegistryJs, generateActionRegistryTs, generateEmptyActionRegistryJs } from "../../transform/server/generateActionRegistry.js";
+import { debug } from "../../debug.js";
+export const buildServerFiles = (actions, rootDir) => {
+    const serverOutDir = path.join(rootDir, 'dist/server');
+    const srcDir = path.join(rootDir, 'src');
+    // Clear /dist/server before starting
+    if (fs.existsSync(serverOutDir)) {
+        fs.rmSync(serverOutDir, { recursive: true });
+        fs.mkdirSync(serverOutDir, { recursive: true });
+    }
+    const actionRegistryJsPath = path.join(serverOutDir, 'actionRegistry.js');
+    if (actions.length > 0) {
+        // Compile and output all standard files, e.g. those which are imported by the user's actions
+        buildStandardFiles(actions, serverOutDir, srcDir);
+        // Then generate a registry file which the server will load
+        buildRegistryFile(actions, srcDir, actionRegistryJsPath);
+    }
+    else {
+        // Create an empty registry file
+        buildEmptyRegistryFile(actionRegistryJsPath);
+    }
+    debug(`Built server with ${actions.length} actions to ${serverOutDir}.`);
+};
+const buildStandardFiles = (actions, serverOutDir, srcDir) => {
+    // Create tmp directory
+    const tmpDir = os.tmpdir();
+    const projectHash = md5(process.cwd());
+    const generatedRegistryFilePath = path.join(tmpDir, `rsf-zero-registry-${projectHash}.ts`);
+    const compilerOptions = {
+        strict: true,
+        module: ModuleKind.ESNext,
+        allowSyntheticDefaultImports: true,
+        skipLibCheck: true,
+        rewriteRelativeImportExtensions: true,
+        outDir: serverOutDir,
+        rootDir: srcDir,
+    };
+    // Generate registry ts file
+    const registryContent = generateActionRegistryTs(actions, generatedRegistryFilePath);
+    fs.writeFileSync(generatedRegistryFilePath, registryContent);
+    debug('wrote action registry ts file to: ' + generatedRegistryFilePath);
+    // Create TypeScript program with the temporary file as entry point
+    const program = createProgram([generatedRegistryFilePath], compilerOptions);
+    // Emit the compiled files
+    const emitResult = program.emit();
+    debug('Built server files to: ' + serverOutDir);
+    // Check for compilation errors
+    const allDiagnostics = program.getSemanticDiagnostics()
+        .concat(program.getSyntacticDiagnostics())
+        .concat(emitResult.diagnostics);
+    if (allDiagnostics.length > 0) {
+        allDiagnostics.forEach(diagnostic => {
+            if (diagnostic.file) {
+                const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+                const message = flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+                console.error(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+            }
+            else {
+                console.error(flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+            }
+        });
+        if (emitResult.emitSkipped) {
+            throw new Error('TypeScript compilation failed');
+        }
+    }
+};
+const buildRegistryFile = (actions, srcDir, actionRegistryJsPath) => {
+    // This file is what the server loads. It imports all the user's actions.
+    // It also exports a map of the action id to the action function.
+    //
+    // There are two ways to build this file, one is to place it in the user's src/ directory
+    // and use tsc to compile it and output it into dist. The other is to directly write it to
+    // dist as a javascript file.
+    //
+    // The first way means we pollute the user's src/ directory, which I don't like, so instead
+    // we do the direct option. A bit less ideal in this codebase, but a nicer DevEx for the user.
+    fs.writeFileSync(actionRegistryJsPath, generateActionRegistryJs(actions, srcDir));
+    debug('wrote action registry js file to: ' + actionRegistryJsPath);
+};
+const buildEmptyRegistryFile = (actionRegistryJsPath) => {
+    // We still need an empty file for the server
+    fs.writeFileSync(actionRegistryJsPath, generateEmptyActionRegistryJs());
+    debug('wrote empty action registry js file to: ' + actionRegistryJsPath);
+};

package/dist/cli/build.js ADDED Viewed

@@ -0,0 +1,12 @@
+import { resolveConfig } from 'vite';
+import { buildServerFiles } from "./build/buildServerFiles.js";
+import { buildClientFiles } from "./build/buildClientFiles.js";
+export const build = async () => {
+    const rootDir = (await resolveConfig({}, 'build', 'production', 'production')).root;
+    // Map used for building the action registry
+    const actions = [];
+    // Build client files
+    await buildClientFiles(rootDir, (action) => actions.push(action));
+    // Build server files
+    buildServerFiles(actions, rootDir);
+};

package/dist/cli/dev/startVite.js ADDED Viewed

@@ -0,0 +1,32 @@
+import { createServer as createViteServer } from "vite";
+import fs from "fs";
+import viteReact from "@vitejs/plugin-react";
+import { transformRsfForClientPlugin } from "../../transform/client/transformRsfForClientPlugin.js";
+import { debug } from "../../debug.js";
+export const startVite = async ({ app, onActionFound }) => {
+    debug('starting dev vite');
+    const vite = await createViteServer({
+        server: { middlewareMode: true },
+        appType: "custom",
+        base: '/',
+        plugins: [
+            viteReact(),
+            transformRsfForClientPlugin(onActionFound),
+        ],
+    });
+    // Use vite's connect instance as middleware.
+    // This will handle serving client-side assets and HMR.
+    app.use(vite.middlewares);
+    // All other routes should be handled by Vite
+    // /{*splat} matches all routes including /
+    app.get("/{*splat}", async (req, res) => {
+        const templatePath = process.cwd() + "/index.html";
+        // 1. Read index.html
+        const template = fs.readFileSync(templatePath, "utf-8");
+        // 2. Apply Vite HTML transforms.
+        const html = await vite.transformIndexHtml(req.originalUrl, template);
+        // 3. Send the rendered HTML back.
+        res.status(200).set({ "Content-Type": "text/html" }).end(html);
+    });
+    return vite;
+};

package/dist/cli/dev.js ADDED Viewed

@@ -0,0 +1,30 @@
+import express from "express";
+import morgan from "morgan";
+import "dotenv/config";
+import { startVite } from "./dev/startVite.js";
+import { createActionRoute } from "./start/createActionRoute.js";
+import { debug } from "../debug.js";
+export const dev = async () => {
+    const app = express();
+    const port = 3000;
+    app.use(morgan("dev"));
+    app.use(express.json());
+    // Dev RSF handler
+    // - create action route
+    const { add: addToActionRegistry } = createActionRoute(app);
+    // - in dev mode, Vite loads files on the fly, so we need to register actions handlers on the fly too
+    const onActionFound = async (action) => {
+        debug("Loading action handler: " + action.id);
+        const module = await vite.ssrLoadModule(`${action.sourceFilePath}`);
+        const actionFn = module[action.name];
+        addToActionRegistry(action.id, actionFn);
+        debug("Loaded action handler: " + action.name);
+    };
+    // Serve the frontend
+    // - transform any actions found for the frontend
+    // - and inform the onActionFound callback above
+    const vite = await startVite({ app, onActionFound });
+    app.listen(port, () => {
+        console.log(`Server is running at http://localhost:${port}`);
+    });
+};

package/dist/cli/start/createActionRoute.js ADDED Viewed

@@ -0,0 +1,54 @@
+import { parse, stringify } from "superjson";
+import { debug } from "../../debug.js";
+export const createActionRoute = (app) => {
+    let actionRegistry = {};
+    const add = (actionId, actionFn) => {
+        debug("Registering server action: " + actionId);
+        actionRegistry[actionId] = actionFn;
+    };
+    const set = (newActionRegistry) => {
+        actionRegistry = newActionRegistry;
+    };
+    app.post("/actions/:actionId", async (req, res) => {
+        const { actionId } = req.params;
+        debug("Received request for action: ", actionId);
+        const actionFn = actionRegistry[actionId];
+        if (!actionFn) {
+            throw new Error('Server does not have this action registered: ' + actionId);
+        }
+        debug("Request body: ", req.body);
+        const serialisedFnArgs = req.body.serialisedFnArgs;
+        const fnArgs = parse(serialisedFnArgs);
+        // Call the action function
+        debug("Request fn args: ", fnArgs);
+        const actionFnReturnValue = await callActionFn(actionId, actionFn, fnArgs);
+        // Serialise the result
+        const serialisedFnResult = serialiseReturnValue(actionId, actionFnReturnValue);
+        res.json({ serialisedFnResult });
+    });
+    return {
+        add,
+        set,
+    };
+};
+const callActionFn = async (actionId, actionFn, fnArgs) => {
+    debug('Calling action: ' + actionId + ' with fn: ' + actionFn + ' with args: ', fnArgs);
+    try {
+        const actionFnReturnValue = await actionFn(...fnArgs);
+        debug('Action ' + actionId + ' return value: ', actionFnReturnValue);
+        return actionFnReturnValue;
+    }
+    catch (e) {
+        throw new Error('Error thrown in action handler ' + actionId + ': ' + e);
+    }
+};
+const serialiseReturnValue = (actionId, value) => {
+    try {
+        const serialised = stringify(value);
+        debug('Serialised action ' + actionId + ' return value: ', serialised);
+        return serialised;
+    }
+    catch (e) {
+        throw new Error('Error serialising ' + actionId + ' return value: ' + e);
+    }
+};

package/dist/cli/start.js ADDED Viewed

@@ -0,0 +1,34 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import path from 'path';
+import express from "express";
+import morgan from "morgan";
+import "dotenv/config";
+import { createActionRoute } from "./start/createActionRoute.js";
+export const start = async () => {
+    const app = express();
+    const port = 3000;
+    app.use(morgan("dev"));
+    app.use(express.json());
+    // Client
+    const staticPath = path.join(process.cwd(), 'dist/client/');
+    console.log('Serving static files from:', staticPath);
+    app.use(express.static('dist/client/'));
+    // Server
+    // - create action route
+    const { set: setActionRegistry } = createActionRoute(app);
+    // - load actionRegistry dynamically
+    const module = await import(__rewriteRelativeImportExtension(path.join(process.cwd(), 'dist/server/actionRegistry.js')));
+    const { actionRegistry } = module;
+    // - register action handlers
+    setActionRegistry(actionRegistry);
+    app.listen(port, () => {
+        console.log(`Server is running at http://localhost:${port}`);
+    });
+};

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { dev } from "./cli/dev.js";
+import { build } from "./cli/build.js";
+import { start } from "./cli/start.js";
+const args = process.argv.slice(2);
+const command = args[0];
+if (command === 'dev') {
+    await dev();
+}
+else if (command === 'build') {
+    await build();
+}
+else if (command === 'start') {
+    await start();
+}
+else {
+    console.log('rsf-zero: Unknown command. Available commands: dev, build, start');
+    process.exit(1);
+}

package/dist/debug.js ADDED Viewed

@@ -0,0 +1,5 @@
+import { debuglog } from "node:util";
+const log = debuglog('rsf-zero');
+export const debug = (message, ...param) => {
+    log(message, ...param);
+};

package/dist/lib/client.js ADDED Viewed

@@ -0,0 +1,22 @@
+import { stringify, parse } from 'superjson';
+export const createActionCaller = (actionName) => {
+    return async (...args) => {
+        try {
+            console.debug("caller called with args: " + args);
+            const result = await fetch("/actions/" + actionName, {
+                method: "POST",
+                body: JSON.stringify({ serialisedFnArgs: stringify(args) }),
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            const parsedResult = await result.json();
+            const deserialisedFnResult = parse(parsedResult.serialisedFnResult);
+            console.debug("deserialisedFnResult: ", deserialisedFnResult);
+            return deserialisedFnResult;
+        }
+        catch (e) {
+            throw new Error('Error calling action ' + actionName + ': ' + e);
+        }
+    };
+};

package/dist/transform/asRelativeImport.js ADDED Viewed

@@ -0,0 +1,19 @@
+import fs from "fs";
+import path from "path";
+/**
+ * Converts any import e.g. absolute path to a relative one.
+ *
+ * Given `/User/x/my-file.ts, /User/x`
+ * Returns `./my-file.ts`
+ *
+ * Given `/User/x/my-file.ts, /User/somewhere-else`
+ * Returns `../x/my-file.ts`
+ *
+ * Can be passed an optional `replaceExtWith` param to replace the extension.
+ */
+export const asRelativeImport = (targetPath, relativeToPath, replaceExtWith) => {
+    const relativeToDirPath = fs.lstatSync(relativeToPath).isDirectory() ? relativeToPath : path.dirname(relativeToPath);
+    const relative = path.relative(relativeToDirPath, targetPath);
+    // Add leading dot slash
+    return relative.startsWith('.') ? relative : './' + relative;
+};

package/dist/transform/client/transformRsfForClientPlugin.js ADDED Viewed

@@ -0,0 +1,20 @@
+import { transformTopLevelRsf } from "./transformTopLevelRsf.js";
+/**
+ * This plugin sees a file with 'use server' and transforms it to a client-side version.
+ *
+ * The client-side version has the original code replaced with an API call to the server for that action.
+ *
+ * This plugin also registers all actions found via the passed onActionFound function.
+ */
+export const transformRsfForClientPlugin = (onActionFound) => {
+    return {
+        name: "vite-plugin-transform-rsf-for-client",
+        transform(code, id, options) {
+            if (options?.ssr) {
+                // plugin is running in the 'dev' command, and loading the module for the server
+                return;
+            }
+            return transformTopLevelRsf(id, code, onActionFound);
+        },
+    };
+};

package/dist/transform/client/transformTopLevelRsf.js ADDED Viewed

@@ -0,0 +1,64 @@
+import * as swc from "@swc/core";
+import { isTopLevelRsfFile } from "../isTopLevelRsfFile.js";
+import { debug } from "../../debug.js";
+import { getActionId } from "../getActionId.js";
+/**
+ * Given a file that starts with 'use server', return a transformed client version of that file.
+ */
+export const transformTopLevelRsf = (id, code, onActionFound) => {
+    if (!isTopLevelRsfFile(id, code)) {
+        return undefined;
+    }
+    debug("Transforming file for client: ", id);
+    const mod = swc.parseSync(code);
+    const exportNames = new Set();
+    for (const item of mod.body) {
+        if (item.type === 'ExportDeclaration') {
+            if (item.declaration.type === 'FunctionDeclaration') {
+                exportNames.add(item.declaration.identifier.value);
+            }
+            else if (item.declaration.type === 'ClassDeclaration') {
+                exportNames.add(item.declaration.identifier.value);
+            }
+            else if (item.declaration.type === 'VariableDeclaration') {
+                for (const d of item.declaration.declarations) {
+                    if (d.id.type === 'Identifier') {
+                        exportNames.add(d.id.value);
+                    }
+                }
+            }
+        }
+        else if (item.type === 'ExportNamedDeclaration') {
+            for (const s of item.specifiers) {
+                if (s.type === 'ExportSpecifier') {
+                    exportNames.add(s.exported ? s.exported.value : s.orig.value);
+                }
+            }
+        }
+        else if (item.type === 'ExportDefaultExpression') {
+            exportNames.add('default');
+        }
+        else if (item.type === 'ExportDefaultDeclaration') {
+            exportNames.add('default');
+        }
+    }
+    let newCode = `
+import { createActionCaller } from 'rsf-zero/client';`;
+    for (const exportName of exportNames) {
+        const actionId = getActionId(id, exportName);
+        onActionFound({
+            id: actionId,
+            sourceFilePath: id,
+            name: exportName,
+        });
+        if (exportName === 'default') {
+            newCode += `
+export default createActionCaller('${actionId}');`;
+        }
+        else {
+            newCode += `
+export const ${exportName} = createActionCaller('${actionId}');`;
+        }
+    }
+    return newCode;
+};

package/dist/transform/collectExportNames.js ADDED Viewed

@@ -0,0 +1,25 @@
+export const collectExportNames = (mod) => {
+    const exportNames = new Set();
+    for (const item of mod.body) {
+        if (item.type === "ExportDeclaration") {
+            if (item.declaration.type === "FunctionDeclaration") {
+                exportNames.add(item.declaration.identifier.value);
+            }
+            else if (item.declaration.type === "VariableDeclaration") {
+                for (const d of item.declaration.declarations) {
+                    if (d.id.type === "Identifier") {
+                        exportNames.add(d.id.value);
+                    }
+                }
+            }
+        }
+        else if (item.type === "ExportNamedDeclaration") {
+            for (const s of item.specifiers) {
+                if (s.type === "ExportSpecifier") {
+                    exportNames.add(s.exported ? s.exported.value : s.orig.value);
+                }
+            }
+        }
+    }
+    return exportNames;
+};

package/dist/transform/extname.js ADDED Viewed

@@ -0,0 +1,10 @@
+export const extname = (filePath) => {
+    const index = filePath.lastIndexOf(".");
+    if (index <= 0) {
+        return "";
+    }
+    if (["/", "."].includes(filePath[index - 1])) {
+        return "";
+    }
+    return filePath.slice(index);
+};

package/dist/transform/getActionId.js ADDED Viewed

@@ -0,0 +1,7 @@
+import md5 from "md5";
+import path from "path";
+export const getActionId = (sourceFilePath, actionName) => {
+    const absolutePath = path.resolve(sourceFilePath);
+    const hash = md5(absolutePath);
+    return `${actionName}_${hash}`;
+};

package/dist/transform/isTopLevelRsfFile.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { extname } from "./extname.js";
+export const isTopLevelRsfFile = (id, code) => {
+    const ext = extname(id);
+    if (ext === ".ts" || ext === ".tsx") {
+        return code.startsWith(`'use server'`) || code.startsWith(`"use server"`);
+    }
+    return false;
+};

package/dist/transform/replaceFileExt.js ADDED Viewed

@@ -0,0 +1,5 @@
+import { extname } from "./extname.js";
+export const replaceFileExt = (path, newExt) => {
+    const originalExt = extname(path);
+    return path.slice(0, -originalExt.length) + newExt;
+};

package/dist/transform/server/generateActionRegistry.js ADDED Viewed

@@ -0,0 +1,60 @@
+import { asRelativeImport } from "../asRelativeImport.js";
+import { replaceFileExt } from "../replaceFileExt.js";
+/**
+ * Create a typescript file that imports all actions. This can then be passed to a tsc to be processed into dist js files.
+ */
+export const generateActionRegistryTs = (actions, registryPath) => {
+    const actionsWithRelativePaths = actions.map(action => {
+        return {
+            ...action,
+            relativeSourceFilePath: asRelativeImport(action.sourceFilePath, registryPath),
+        };
+    });
+    let newCode = `// Generated by RSF Zero, do not modify
+`;
+    for (const action of actionsWithRelativePaths) {
+        if (action.name === 'default') {
+            newCode += `import ${action.id} from '${action.relativeSourceFilePath}';
+`;
+        }
+        else {
+            newCode += `import { ${action.name} as ${action.id} } from '${action.relativeSourceFilePath}';
+`;
+        }
+    }
+    return newCode;
+};
+/**
+ * Create a javascript file that imports all actions. This is used by the start command to load action functions when the server starts.
+ */
+export const generateActionRegistryJs = (actions, relativeToDir) => {
+    const actionsWithRelativePaths = actions.map(action => {
+        return {
+            ...action,
+            relativeSourceFilePathAsJs: replaceFileExt(asRelativeImport(action.sourceFilePath, relativeToDir), '.js'),
+        };
+    });
+    let newCode = `// Generated by RSF Zero, do not modify
+`;
+    for (const action of actionsWithRelativePaths) {
+        if (action.name === 'default') {
+            newCode += `import ${action.id} from '${action.relativeSourceFilePathAsJs}';
+`;
+        }
+        else {
+            newCode += `import { ${action.name} as ${action.id} } from '${action.relativeSourceFilePathAsJs}';
+`;
+        }
+    }
+    newCode += `
+export const actionRegistry = {
+${actionsWithRelativePaths.map(action => `"${action.id}": ${action.id},`).join('\n')}
+};
+`;
+    return newCode;
+};
+export const generateEmptyActionRegistryJs = () => {
+    return `// Generated by RSF Zero, do not modify
+export const actionRegistry = {};
+`;
+};

package/dist/types.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/package.json ADDED Viewed

@@ -0,0 +1,46 @@
+{
+  "name": "rsf-zero",
+  "type": "module",
+  "version": "0.1.0",
+  "scripts": {
+    "build": "rm -rf ./dist && tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@swc/core": "^1.12.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "dotenv": "^17.2.1",
+    "express": "^5.1.0",
+    "morgan": "^1.10.0",
+    "superjson": "^2.2.2",
+    "vite": "^6.3.5"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.2",
+    "@types/express": "^5.0.3",
+    "@types/md5": "^2",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^24.1.0",
+    "md5": "^2.3.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "exports": {
+    "./client": {
+      "types": "./dist/lib/client.d.ts",
+      "default": "./dist/lib/client.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "packageManager": "yarn@4.6.0",
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "bin": "dist/cli.js"
+}