eclipsa 0.1.0 → 0.1.1

package/vite/dev-app/mod.ts

@@ -1,88 +0,0 @@
-import { Hono, type Context } from 'hono'
-import type { DevEnvironment, ResolvedConfig, ViteDevServer } from 'vite'
-import type { ModuleRunner } from 'vite/module-runner'
-import { renderToString } from '../../jsx/mod.ts'
-import type { SSRRootProps } from '../../core/types.ts'
-import { Fragment } from '../../jsx/jsx-dev-runtime.ts'
-import { createRoutes, type RouteEntry } from '../utils/routing.ts'
-import type { DevClientInfo } from '../../core/dev-client/types.ts'
-
-interface DevAppInit {
-  resolvedConfig: ResolvedConfig
-  devServer: ViteDevServer
-  runner: ModuleRunner
-  ssrEnv: DevEnvironment
-}
-
-const createDevApp = async (init: DevAppInit) => {
-  const app = new Hono()
-
-  const createHandler = (entry: RouteEntry) => async (c: Context) => {
-    const [
-      { default: Page },
-      { default: SSRRoot }
-    ] = await Promise.all([
-      await init.runner.import(entry.filePath),
-      await init.runner.import('/app/+ssr-root.tsx')
-    ])
-
-    const page = Page()
-    const parent = SSRRoot({
-      children: page,
-      head: {
-        type: Fragment,
-        isStatic: true,
-        props: {
-          children: [
-            {
-              type: 'script',
-              isStatic: true,
-              props: {
-                children: 'import("/@vite/client")'
-              } 
-            },
-            {
-              type: 'script',
-              props: {
-                type: 'module',
-                src: '/app/+client.dev.tsx'
-              }
-            },
-            {
-              type: 'script',
-              isStatic: true,
-              props: {
-                type: 'text/eclipsa+devinfo',
-                id: 'eclipsa-devinfo',
-                children: JSON.stringify({
-                  filePath: entry.filePath
-                } satisfies DevClientInfo)
-              }
-            }
-          ]
-        }
-      }
-    } satisfies SSRRootProps)
-  
-    return c.html(renderToString(parent))
-  }
-
-  for (const entry of await createRoutes(init.resolvedConfig.root)) {
-    app.get(entry.honoPath, createHandler(entry))
-  }
-
-  return app
-}
-export const createDevFetch = (
-  init: DevAppInit,
-): (req: Request) => Promise<Response | undefined> => {
-  let app = createDevApp(init)
-
-  return async (req) => {
-    const fetched = await (await app).fetch(req)
-    if (fetched.status === 404) {
-      return
-    }
-    return fetched
-  }
-}

package/vite/mod.ts

@@ -1,76 +0,0 @@
-import {
-  createServerModuleRunner,
-  DevEnvironment,
-  type Plugin,
-  type ResolvedConfig,
-} from 'vite'
-import { createDevFetch } from './dev-app/mod.ts'
-import {
-  incomingMessageToRequest,
-  responseForServerResponse,
-} from '../utils/node-connect.ts'
-import { transformJSX } from '../transformers/dev-ssr/mod.ts'
-import { transformClientDevJSX } from '../transformers/dev-client/mod.ts'
-
-export const eclipsa = (): Plugin => {
-  let config: ResolvedConfig
-  return {
-    name: 'vite-plugin-eclipsa',
-    config() {
-      return {
-        esbuild: {
-          jsxFactory: 'jsx',
-          jsxImportSource: '@xely/eclipsa',
-          jsx: 'preserve',
-        },
-        //environments: {
-         /* ssr: {
-            dev: {
-              createEnvironment(name, config, _context) {
-                return new DevEnvironment(name, config, {
-                  hot: false,
-                })
-              },
-            },
-          },*/
-       // },
-      }
-    },
-    configResolved(resolvedConfig) {
-      config = resolvedConfig
-    },
-    configureServer(server) {
-      const ssrEnv = server.environments.ssr
-      const runner = createServerModuleRunner(ssrEnv, {
-        hmr: false,
-      })
-      const devFetch = createDevFetch({
-        resolvedConfig: config,
-        devServer: server,
-        runner,
-        ssrEnv,
-      })
-      server.middlewares.use(async (req, res, next) => {
-        const webReq = incomingMessageToRequest(req)
-        const webRes = await devFetch(webReq)
-        if (webRes) {
-          responseForServerResponse(webRes, res)
-          return
-        }
-        next()
-      })
-    },
-    hotUpdate(options) {
-      options.server.hot.send({ type: 'full-reload' })
-    },
-    transform(code, id) {
-      if (id.endsWith('.tsx')) {
-        const result = (this.environment.name === 'ssr' ? transformJSX : transformClientDevJSX)(code)
-        return {
-          code: result
-        }
-      }
-      return
-    },
-  }
-}

package/vite/utils/routing.ts

@@ -1,26 +0,0 @@
-import fg from 'fast-glob'
-import path from 'node:path'
-
-// WIP
-const filePathToHonoPath = (filePath: string) => {
-  const segments = filePath.split('/').slice(0, -1)
-
-  return segments.join('/') || '/'
-}
-
-export interface RouteEntry {
-  filePath: string
-  honoPath: string
-}
-export const createRoutes = async (root: string): Promise<RouteEntry[]> => {
-  const appDir = path.join(root, 'app')
-  const result = []
-  for await (const entry of fg.stream(path.join(root, '/**/+page.tsx'))) {
-    const relativePath = path.relative(appDir, entry.toString())
-    result.push({
-      filePath: entry.toString(),
-      honoPath: filePathToHonoPath(relativePath)
-    })
-  }
-  return result
-}