polen 0.0.1

package/build/lib/vite/virtual-identifier.js

@@ -0,0 +1,94 @@
+import { Debug } from '../debug/_namespace.js';
+// TODO: use async hooks in debug to get namespace
+const debug = Debug.create(`polen:vite:build`);
+export const idPrefix = `virtual:`;
+export const resolvedPrefix = `\0`;
+const createResolved = (id) => `${resolvedPrefix}${id}`;
+const createId = (id) => `${idPrefix}${id}`;
+const normalizeId = (parameters) => {
+    if (!parameters.separator)
+        return parameters.id;
+    return parameters.id.replace(new RegExp(`^${parameters.separator}`), ``);
+};
+export const createNamespaceFactory = (namespace, separator = `/`) => {
+    return idOrIdSegments => {
+        const id = Array.isArray(idOrIdSegments)
+            ? idOrIdSegments.join(separator)
+            : idOrIdSegments;
+        return create({
+            id,
+            namespace,
+            separator,
+        });
+    };
+};
+const create = (parameters) => {
+    const separator = parameters.separator ?? `/`;
+    const idNormalized = normalizeId({ id: parameters.id, separator });
+    const idNamespaced = parameters.namespace
+        ? `${parameters.namespace}${separator}${idNormalized}`
+        : idNormalized;
+    const id = createId(idNamespaced);
+    const resolved = createResolved(id);
+    return {
+        id,
+        resolved,
+        separator,
+        namespace: parameters.namespace ?? null,
+    };
+};
+// Transformers
+export const toHookResolveId = (virtualIdentifier) => {
+    return id => {
+        if (id === virtualIdentifier.id) {
+            return virtualIdentifier.resolved;
+        }
+        return undefined;
+    };
+};
+export const toHookLoad = (virtualIdentifier, loader) => {
+    return async (...args) => {
+        // debug(`load candidate`, { virtualIdentifier, args })
+        if (args[0] === virtualIdentifier.resolved) {
+            debug(`will load`, { virtualIdentifier });
+            const result = await loader(...args);
+            debug(`did load`, { virtualIdentifier, result });
+            return result;
+        }
+        return undefined;
+    };
+};
+export const toHooks = (virtualIdentifier, loader) => {
+    return {
+        resolveId: toHookResolveId(virtualIdentifier),
+        load: toHookLoad(virtualIdentifier, loader),
+    };
+};
+export const toHookLoad$FromMap = (virtualIdentifierToLoaderMap) => {
+    const loaderStack = [...virtualIdentifierToLoaderMap.entries()].map(([vi, loader]) => toHookLoad(vi, loader));
+    return async (...args) => {
+        for (const loader of loaderStack) {
+            const result = await loader(...args);
+            if (result !== undefined)
+                return result;
+        }
+        return undefined;
+    };
+};
+export const toHookResolveId$FromMap = (virtualIdentifierToLoaderMap) => {
+    return async (...args) => {
+        const resolversStack = [...virtualIdentifierToLoaderMap.keys()].map(toHookResolveId);
+        for (const resolver of resolversStack) {
+            const result = await resolver(...args);
+            if (result !== undefined)
+                return result;
+        }
+        return undefined;
+    };
+};
+export const toHooks$FromMap = (virtualIdentifierToLoaderMap) => {
+    return {
+        resolveId: toHookResolveId$FromMap(virtualIdentifierToLoaderMap),
+        load: toHookLoad$FromMap(virtualIdentifierToLoaderMap),
+    };
+};

package/build/lib/vite-plugins/_exports.d.ts

@@ -0,0 +1,2 @@
+export * from './build-logger.js';
+export * from './output-logger.js';

package/build/lib/vite-plugins/_exports.js

@@ -0,0 +1,2 @@
+export * from './build-logger.js';
+export * from './output-logger.js';

package/build/lib/vite-plugins/_namespace.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Export unified VitePlugins namespace
+ */
+export * as Plugins from './_exports.js';

package/build/lib/vite-plugins/_namespace.js

@@ -0,0 +1,4 @@
+/**
+ * Export unified VitePlugins namespace
+ */
+export * as Plugins from './_exports.js';

package/build/lib/vite-plugins/build-logger.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare const BuildLogger: Plugin;

package/build/lib/vite-plugins/build-logger.js

@@ -0,0 +1,30 @@
+export const BuildLogger = {
+    // https://rollupjs.org/plugin-development/#build-hooks
+    name: `build-logger`,
+    buildStart(...args) {
+        console.log(`buildStart`, args);
+    },
+    resolveId(...args) {
+        console.log(`resolveId`, args);
+    },
+    load(...args) {
+        console.log(`load`, JSON.stringify(args));
+    },
+    shouldTransformCachedModule(...args) {
+        console.log(`shouldTransformCachedModule`, args);
+    },
+    transform(...args) {
+        // console.log(`transform`)
+        console.log(`transform`, args);
+        return args[0];
+    },
+    moduleParsed(...args) {
+        console.log(`\nmoduleParsed`, args);
+    },
+    resolveDynamicImport(...args) {
+        console.log(`resolveDynamicImport`, args);
+    },
+    buildEnd(...args) {
+        console.log(`buildEnd`, args);
+    },
+};

package/build/lib/vite-plugins/output-logger.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare const OutputLogger: Plugin;

package/build/lib/vite-plugins/output-logger.js

@@ -0,0 +1,12 @@
+export const OutputLogger = {
+    name: `output-logger`,
+    outputOptions(...args) {
+        console.log(`outputOptions`, args);
+    },
+    renderStart(...args) {
+        console.log(`renderStart`, args);
+    },
+    renderDynamicImport(...args) {
+        console.log(`renderDynamicImport`, args);
+    },
+};

package/build/vite-plugin/_exports.d.ts

@@ -0,0 +1,3 @@
+import { Configurator } from './configurator/_namespace.js';
+import { Vite } from '../lib/vite/_namespace.js';
+export declare const VitePlugin: (polenConfigInput?: Configurator.ConfigInput) => Vite.PluginOption[];

package/build/vite-plugin/_exports.js

@@ -0,0 +1,81 @@
+import { Configurator } from './configurator/_namespace.js';
+import { Vite } from '../lib/vite/_namespace.js';
+import ReactVite from '@vitejs/plugin-react';
+import { Fs } from '../lib/fs/_namespace.js';
+import { virtualIdentifier } from './helpers.js';
+import { Build } from './build.js';
+import { nodeAdapter as HonoDevServerNodeAdapter } from '@hono/vite-dev-server/node';
+import HonoDevServer from '@hono/vite-dev-server';
+const virtualIdentifierAssetGraphqlSchema = virtualIdentifier([`assets`, `graphql-schema`]);
+const codes = {
+    MODULE_LEVEL_DIRECTIVE: `MODULE_LEVEL_DIRECTIVE`,
+    CIRCULAR_DEPENDENCY: `CIRCULAR_DEPENDENCY`,
+};
+export const VitePlugin = (polenConfigInput) => {
+    const polenConfig = Configurator.normalizeInput(polenConfigInput);
+    const debug = true;
+    return [
+        HonoDevServer({
+            entry: polenConfig.paths.appTemplate.entryServer,
+            adapter: HonoDevServerNodeAdapter,
+        }),
+        ReactVite(),
+        {
+            name: `polen-virtual-graphql-schema`,
+            ...Vite.VirtualIdentifier.toHooks(virtualIdentifierAssetGraphqlSchema, async () => {
+                const schema = await Fs.readFile(polenConfig.schema.path, `utf-8`);
+                const moduleContent = `export default ${JSON.stringify(schema)}`;
+                return moduleContent;
+            }),
+        },
+        {
+            name: `polen-build-client`,
+            apply: `build`,
+            applyToEnvironment: Vite.isEnvironmentClient,
+            // HACK: For some reason the ?url import doesn't lead to a rewrite in the build.
+            // Furthermore we need to rely on the manifest to get its final name because it is
+            // generated by the client build before the server build.
+            // However, we still need the asset in development.
+            // But we cannot exclude the import in build.
+            // So this does that for us but it is really hacky.
+            // FIXME
+            // 1. Raise issue about having ?url lead to expected build path rewrite?
+            // 2. And: Move asset generation to server build?
+            // 3. And/or: Use Vite Environments API?
+            generateBundle(_, bundle, isWrite) {
+                if (isWrite) {
+                    for (const chunkOrAsset of Object.values(bundle)) {
+                        if (chunkOrAsset.type === `asset` && chunkOrAsset.names.includes(`entry.client.jsx`)) {
+                            // eslint-disable-next-line
+                            delete bundle[chunkOrAsset.fileName];
+                        }
+                    }
+                }
+            },
+            onLog(level, message) {
+                if (level === `warn` && message.code === codes.MODULE_LEVEL_DIRECTIVE &&
+                    message.id?.includes(`@radix-ui`))
+                    return;
+            },
+            config() {
+                return {
+                    environments: {
+                        client: {
+                            build: {
+                                minify: !debug,
+                                manifest: true,
+                                rollupOptions: {
+                                    input: [polenConfig.paths.appTemplate.entryClient],
+                                },
+                            },
+                        },
+                    },
+                };
+            },
+        },
+        Build({
+            entryServerPath: polenConfig.paths.appTemplate.entryServer,
+            debug: debug,
+        }),
+    ];
+};

package/build/vite-plugin/build.d.ts

@@ -0,0 +1,5 @@
+import { Vite } from '../lib/vite/_namespace.js';
+export declare const Build: (parameters: {
+    entryServerPath: string;
+    debug?: boolean;
+}) => Vite.Plugin[];

package/build/vite-plugin/build.js

@@ -0,0 +1,144 @@
+import { CodeBuilder } from '../lib/code-builder/_namespace.js';
+import { Fs } from '../lib/fs/_namespace.js';
+import { Path } from '../lib/path/_namespace.js';
+import { Vite } from '../lib/vite/_namespace.js';
+import { virtualIdentifier } from './helpers.js';
+import { defu } from 'defu';
+const viServerEntry = virtualIdentifier([`server`, `entry`]);
+export const Build = (parameters) => {
+    const config = defu(parameters, { debug: false });
+    let viteConfigResolved;
+    return [Manifest(), {
+            name: `polen-ssr-build`,
+            apply: `build`,
+            applyToEnvironment: Vite.isEnvironmentSsr,
+            configResolved(config) {
+                viteConfigResolved = config;
+            },
+            ...Vite.VirtualIdentifier.toHooks$FromMap(new Map([
+                [viServerEntry, () => {
+                        const serverPort = viteConfigResolved.server.port + 1;
+                        const entryServerPath = Path.absolutify(config.entryServerPath, viteConfigResolved.root);
+                        const entrServeryViteGlobPath = `/` +
+                            Path.relative(viteConfigResolved.root, entryServerPath);
+                        const staticServingPaths = {
+                            // todo
+                            // relative from CWD of process that boots node server
+                            // can easily break! Use path relative in server??
+                            dirPath: `./dist`,
+                            routePath: `/${viteConfigResolved.build.assetsDir}/*`,
+                        };
+                        const code = CodeBuilder.create();
+                        const _ = {
+                            app: `app`,
+                            entry: `entry`,
+                            entries: `entries`,
+                        };
+                        code(`import { Hono } from 'hono'`);
+                        code(``);
+                        code(`const ${_.app} = new Hono()`);
+                        code(``);
+                        code(``);
+                        code(`// Static Files`);
+                        code(``);
+                        code(`import { serveStatic } from '@hono/node-server/serve-static'`);
+                        code(``);
+                        code(`${_.app}.use(
+    				'${staticServingPaths.routePath}',
+    				serveStatic({ root: '${staticServingPaths.dirPath}' })
+    			)`);
+                        code(``);
+                        code(``);
+                        code(`// Entries`);
+                        code(``);
+                        code(`const ${_.entries} = import.meta.glob(
+    				['${entrServeryViteGlobPath}'],
+    				{ import: 'default', eager: true }
+    			)`);
+                        code(``);
+                        code(`/** @see https://github.com/honojs/hono/issues/4051 */`);
+                        code(`const delegate = (app1, method, path, app2) => {
+						app1.on(method, path, (c) => {
+							// Throws if executionCtx is not available
+							// https://hono.dev/docs/api/context#executionctx
+							let maybeExecutionContext
+							try { maybeExecutionContext = c.executionCtx }
+							catch {}
+							return app2.fetch(c.req.raw, c.env, maybeExecutionContext)
+						})
+					}`);
+                        code(`for (const ${_.entry} of Object.values(${_.entries})) {
+						delegate(${_.app}, 'all', '*', ${_.entry})
+    			}`);
+                        code(``);
+                        code(``);
+                        code(`// Start Server`);
+                        code(``);
+                        code(`import { serve } from '@hono/node-server'`);
+                        code(`serve({ fetch: ${_.app}.fetch, port: ${serverPort.toString()} })`);
+                        return code.render();
+                    }],
+            ])),
+            config() {
+                return {
+                    environments: {
+                        ssr: {
+                            build: {
+                                emptyOutDir: false,
+                                minify: !config.debug,
+                                rollupOptions: {
+                                    input: viServerEntry.id,
+                                },
+                            },
+                        },
+                    },
+                };
+            },
+            // generateBundle(_, bundle, isWrite) {
+            //   if (isWrite) {
+            //     for (const chunkOrAsset of Object.values(bundle)) {
+            //       console.log(chunkOrAsset)
+            //       if (chunkOrAsset.type === `chunk`) {
+            //         if (chunkOrAsset.facadeModuleId === viClientManifest.resolved) {
+            //           // eslint-disable-next-line
+            //           delete bundle[chunkOrAsset.fileName]
+            //         }
+            //       }
+            //     }
+            //   }
+            // },
+            async closeBundle() {
+                /**
+                 * clean up the manifest. Was generated by client. For server build. Not needed after (unless debugging).
+                 */
+                if (!config.debug) {
+                    await Fs.rmDirIfExists(Path.join(viteConfigResolved.root, viteConfigResolved.build.outDir, `.vite`));
+                }
+            },
+        }];
+};
+const viClientManifest = virtualIdentifier([`vite`, `client`, `manifest`]);
+const Manifest = () => {
+    let configEnv;
+    let viteConfigResolved;
+    return {
+        name: `polen-manifest`,
+        config(_, configEnv_) {
+            configEnv = configEnv_;
+        },
+        configResolved(config) {
+            viteConfigResolved = config;
+        },
+        ...Vite.VirtualIdentifier.toHooks$FromMap(new Map([
+            [viClientManifest, async () => {
+                    // In development or client build just return an empty manifest
+                    if (configEnv.mode === Vite.ModeName.dev) {
+                        return `export default {}`;
+                    }
+                    const manifestPath = Path.join(viteConfigResolved.root, viteConfigResolved.build.outDir, `.vite`, `manifest.json`);
+                    const module = await import(manifestPath, { with: { type: `json` } });
+                    return `export default ${JSON.stringify(module.default)}`;
+                }],
+        ])),
+    };
+};

package/build/vite-plugin/configurator/_namespace.d.ts

@@ -0,0 +1 @@
+export * as Configurator from './main.js';

package/build/vite-plugin/configurator/_namespace.js

@@ -0,0 +1 @@
+export * as Configurator from './main.js';

package/build/vite-plugin/configurator/main.d.ts

@@ -0,0 +1,35 @@
+export interface ConfigInput {
+    /**
+     * Path to the GraphQL schema file
+     */
+    schemaPath?: string;
+    /**
+     * Whether to enable SSR
+     *
+     * @defaultValue true
+     */
+    ssr?: boolean;
+}
+export interface Config {
+    mode: string;
+    schema: {
+        path: string;
+    };
+    ssr: {
+        enabled: boolean;
+    };
+    aliases: {
+        entryServer: string;
+    };
+    paths: {
+        workspaceDir: string;
+        appTemplate: {
+            dir: string;
+            entryClient: string;
+            entryServer: string;
+        };
+        outDir: string;
+        outViteDir: string;
+    };
+}
+export declare const normalizeInput: (configInput?: ConfigInput) => Config;

package/build/vite-plugin/configurator/main.js

@@ -0,0 +1,36 @@
+import { Path } from '../../lib/path/_namespace.js';
+const pathAppTemplateDir = Path.join(import.meta.dirname, `../../app-template`);
+const workspaceDir = process.cwd();
+const outDir = Path.join(workspaceDir, `dist`);
+const configInputDefaults = {
+    mode: `client`,
+    schema: {
+        path: Path.join(workspaceDir, `schema.graphql`),
+    },
+    ssr: {
+        enabled: true,
+    },
+    aliases: {
+        entryServer: `#polen/server/entry`,
+    },
+    paths: {
+        appTemplate: {
+            dir: pathAppTemplateDir,
+            entryServer: Path.join(pathAppTemplateDir, `entry.server.jsx`),
+            entryClient: Path.join(pathAppTemplateDir, `entry.client.jsx`),
+        },
+        workspaceDir,
+        outDir: Path.join(workspaceDir, `build`),
+        outViteDir: Path.join(outDir),
+    },
+};
+export const normalizeInput = (configInput) => {
+    const config = structuredClone(configInputDefaults);
+    if (configInput?.ssr !== undefined) {
+        config.ssr.enabled = configInput.ssr;
+    }
+    if (configInput?.schemaPath !== undefined) {
+        config.schema.path = Path.absolutify(configInput.schemaPath, config.paths.workspaceDir);
+    }
+    return config;
+};

package/build/vite-plugin/helpers.d.ts

@@ -0,0 +1,2 @@
+import { Vite } from '../lib/vite/_namespace.js';
+export declare const virtualIdentifier: (idOrIdSegments: string | string[]) => Vite.VirtualIdentifier.VirtualIdentifier;

package/build/vite-plugin/helpers.js

@@ -0,0 +1,2 @@
+import { Vite } from '../lib/vite/_namespace.js';
+export const virtualIdentifier = Vite.VirtualIdentifier.createNamespaceFactory(`polen`);

package/build/vite-plugin/renderer.d.ts

@@ -0,0 +1,2 @@
+import serverEntryHandler from '#pollen/server/entry';
+export default serverEntryHandler;

package/build/vite-plugin/renderer.js

@@ -0,0 +1,3 @@
+// @ts-expect-error
+import serverEntryHandler from '#pollen/server/entry';
+export default serverEntryHandler;

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "polen",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": "./build/_namespace.js",
+    "./exports": "./build/_exports.js"
+  },
+  "files": [
+    "build"
+  ],
+  "dependencies": {
+    "@hono/node-server": "^1.14.0",
+    "@hono/vite-build": "^1.5.0",
+    "@hono/vite-dev-server": "^0.19.0",
+    "@radix-ui/themes": "^3.2.1",
+    "consola": "^3.4.2",
+    "defu": "^6.1.4",
+    "es-toolkit": "^1.34.1",
+    "fuse.js": "^7.1.0",
+    "get-port-please": "^3.1.2",
+    "graphql": "^16.10.0",
+    "hono": "^4.7.5",
+    "marked": "^15.0.7",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-helmet-async": "^2.0.5",
+    "react-markdown": "^10.1.0",
+    "react-router": "^7.5.0",
+    "rollup": "^4.39.0",
+    "tsx": "^4.19.3",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.28.1",
+    "@eslint/js": "^9.24.0",
+    "@stylistic/eslint-plugin": "^4.2.0",
+    "@tsconfig/strictest": "^2.0.5",
+    "@types/node": "^22.14.0",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.1",
+    "@typescript-eslint/eslint-plugin": "^8.29.0",
+    "@typescript-eslint/parser": "^8.29.0",
+    "@vitejs/plugin-react": "^4.3.4",
+    "eslint": "^9.24.0",
+    "eslint-plugin-deprecation": "^3.0.0",
+    "eslint-plugin-only-warn": "^1.1.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "eslint-plugin-tsdoc": "^0.4.0",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "globals": "^16.0.0",
+    "publint": "^0.3.10",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.29.0",
+    "vite": "^6.2.5",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.1.1"
+  },
+  "peerDependencies": {
+    "vite": "^6.2.5"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "build:watch:emit": "tsc --watch --nocheck",
+    "build:emit": "tsc --noCheck",
+    "fix": "pnpm fix:lint && pnpm fix:format",
+    "fix:lint": "eslint . --fix",
+    "fix:format": "dprint fmt",
+    "check": "pnpm check:format && pnpm check:lint && pnpm check:types && pnpm check:publint",
+    "check:format": "dprint check",
+    "check:lint": "eslint . --max-warnings 0",
+    "check:types": "tsc --noEmit",
+    "check:publint": "publint run --strict"
+  }
+}