refactor: cleanup

Author: Je

app.ts

@@ -9,7 +9,7 @@ import util, { hashShort } from './util.ts'
 export function ALEPH({ initial }: {
     initial: {
         manifest: AppManifest
-        pageModules: Record<string, { moduleId: string, hash: string }>
+        pageModules: Record<string, Module>
         url: RouterURL
         data: Record<string, any>
         components: Record<string, ComponentType<any>>
@@ -80,16 +80,16 @@ export function ALEPH({ initial }: {
             console.log('[DATA]', data)
             setData(data)
         }
-        const onAddModule = async ({ moduleId, hash }: Module) => {
-            if (moduleId === '/404.js') {
-                const { default: Component } = await import(getModuleImportUrl(baseUrl, { moduleId, hash }) + '?t=' + Date.now())
+        const onAddModule = async (mod: Module) => {
+            if (mod.id === '/404.js') {
+                const { default: Component } = await import(getModuleImportUrl(baseUrl, mod) + '?t=' + Date.now())
                 if (util.isLikelyReactComponent(Component)) {
                     setE404({ Component })
                 } else {
                     setE404({ Component: E404Page })
                 }
-            } else if (moduleId === '/app.js') {
-                const { default: Component } = await import(getModuleImportUrl(baseUrl, { moduleId, hash }) + '?t=' + Date.now())
+            } else if (mod.id === '/app.js') {
+                const { default: Component } = await import(getModuleImportUrl(baseUrl, mod) + '?t=' + Date.now())
                 if (util.isLikelyReactComponent(Component)) {
                     setApp({ Component })
                 } else {
@@ -98,15 +98,15 @@ export function ALEPH({ initial }: {
                         Component: E501App
                     }))
                 }
-            } else if (moduleId === '/data.js' || moduleId === '/data/index.js') {
-                const { default: data } = await import(getModuleImportUrl(baseUrl, { moduleId, hash }) + '?t=' + Date.now())
+            } else if (mod.id === '/data.js' || mod.id === '/data/index.js') {
+                const { default: data } = await import(getModuleImportUrl(baseUrl, mod) + '?t=' + Date.now())
                 console.log('[DATA]', data)
                 setData(data)
-            } else if (moduleId.startsWith('/pages/')) {
-                const pagePath = util.trimSuffix(moduleId, '.js').replace(/\s+/g, '-').replace(/\/?index$/i, '/')
+            } else if (mod.id.startsWith('/pages/')) {
+                const pagePath = util.trimSuffix(mod.id, '.js').replace(/\s+/g, '-').replace(/\/?index$/i, '/')
                 setPageModules(pageModules => ({
                     ...pageModules,
-                    [pagePath]: { moduleId, hash }
+                    [pagePath]: mod
                 }))
             }
         }
@@ -120,10 +120,10 @@ export function ALEPH({ initial }: {
                 setData({})
             } else if (moduleId.startsWith('/pages/')) {
                 setPageModules(pageModules => {
-                    const newPageModules: Record<string, { moduleId: string, hash: string }> = {}
+                    const newPageModules: Record<string, Module> = {}
                     for (const pagePath in pageModules) {
                         const mod = pageModules[pagePath]
-                        if (mod.moduleId !== moduleId) {
+                        if (mod.id !== moduleId) {
                             newPageModules[pagePath] = mod
                         }
                     }
@@ -192,6 +192,6 @@ export async function redirect(url: string, replace: boolean) {
     events.emit('popstate', { type: 'popstate' })
 }
 
-export function getModuleImportUrl(baseUrl: string, { moduleId, hash }: Module) {
-    return util.cleanPath(baseUrl + '/_aleph/' + moduleId.replace(/\.js$/, `.${hash.slice(0, hashShort)}.js`))
+export function getModuleImportUrl(baseUrl: string, mod: Module) {
+    return util.cleanPath(baseUrl + '/_aleph/' + mod.id.replace(/\.js$/, `.${mod.hash.slice(0, hashShort)}.js`))
 }

bootstrap.ts

@@ -10,10 +10,10 @@ export default async function bootstrap({
     baseUrl,
     defaultLocale,
     locales,
-    keyModules,
+    coreModules,
     pageModules
 }: AppManifest & {
-    keyModules: Record<string, Module>
+    coreModules: Record<string, Module>
     pageModules: Record<string, Module>
 }) {
     const { document } = window as any
@@ -46,9 +46,9 @@ export default async function bootstrap({
         { default: E404 },
         { default: Page }
     ] = await Promise.all([
-        keyModules.data ? import(getModuleImportUrl(baseUrl, keyModules.data)) : Promise.resolve({ default: {} }),
-        keyModules.app ? import(getModuleImportUrl(baseUrl, keyModules.app)) : Promise.resolve({}),
-        keyModules['404'] ? import(getModuleImportUrl(baseUrl, keyModules['404'])) : Promise.resolve({}),
+        coreModules.data ? import(getModuleImportUrl(baseUrl, coreModules.data)) : Promise.resolve({ default: {} }),
+        coreModules.app ? import(getModuleImportUrl(baseUrl, coreModules.app)) : Promise.resolve({}),
+        coreModules['404'] ? import(getModuleImportUrl(baseUrl, coreModules['404'])) : Promise.resolve({}),
         pageModule ? import(getModuleImportUrl(baseUrl, pageModule)) : Promise.resolve({}),
     ])
     const el = React.createElement(

cli.ts

@@ -2,7 +2,7 @@ import { createHtml } from './html.ts'
 import log from './log.ts'
 import { getContentType } from './server/mime.ts'
 import { listenAndServe, path, ServerRequest, walk } from './std.ts'
-import util from './util.ts'
+import util, { existsDirSync, existsFileSync } from './util.ts'
 import { version } from './version.ts'
 
 const commands = ['init', 'fetch', 'dev', 'start', 'build']
@@ -89,7 +89,7 @@ async function main() {
     }
 
     // proxy https://deno.land/x/aleph
-    if (util.existsFile('./import_map.json')) {
+    if (existsFileSync('./import_map.json')) {
         const { imports } = JSON.parse(Deno.readTextFileSync('./import_map.json'))
         Object.assign(globalThis, { ALEPH_IMPORT_MAP: { imports } })
         if (imports['https://deno.land/x/aleph/']) {
@@ -150,7 +150,7 @@ async function main() {
         const walkOptions = { includeDirs: false, exts: ['.js', '.jsx', '.mjs', '.ts', '.tsx'], skip: [/\.d\.ts$/i], dep: 1 }
         const pagesDir = path.join(path.resolve(args[0] || '.'), 'pages')
         let hasIndexPage = false
-        if (util.existsDir(pagesDir)) {
+        if (existsDirSync(pagesDir)) {
             for await (const { path: p } of walk(pagesDir, walkOptions)) {
                 if (path.basename(p).split('.')[0] === 'index') {
                     hasIndexPage = true
@@ -167,8 +167,8 @@ async function main() {
     const command = hasCommand ? args.shift() : 'dev'
     import(`./cli/${command}.ts`).then(({ default: cmd }) => {
         const appDir = path.resolve(args[0] || '.')
-        if (command !== 'init' && !util.existsDir(appDir)) {
-            log.fatal('No such app directory:', appDir)
+        if (command !== 'init' && !existsDirSync(appDir)) {
+            log.fatal('No such directory:', appDir)
         }
         cmd(appDir, argOptions)
     })

head.ts

@@ -1,5 +1,5 @@
 import React, { Children, createElement, isValidElement, PropsWithChildren, ReactElement, ReactNode, useEffect } from 'https://esm.sh/react'
-import { resetImports } from './importor.ts'
+import { importAll } from './importor.ts'
 import util from './util.ts'
 
 const serverHeadElements: Array<{ type: string, props: Record<string, any> }> = []
@@ -28,10 +28,7 @@ export async function renderHead(styleModules?: string[]) {
             }
         }
     })
-    await Promise.all(resetImports().map(p => {
-        const { appDir, buildId } = (window as any).ALEPH_ENV as { appDir: string, buildId: string }
-        return util.cleanPath(`${appDir}/.aleph/build-${buildId}/${p}`)
-    }).map(p => import('file://' + p)))
+    await importAll()
     styleModules?.filter(id => serverStyles.has(id)).forEach(id => {
         const { css, asLink } = serverStyles.get(id)!
         if (asLink) {

importor.ts

@@ -3,11 +3,12 @@ import util, { reStyleModuleExt } from './util.ts'
 
 const serverImports: Set<string> = new Set()
 
-// reset imports and returns them
-export function resetImports() {
-    const a = Array.from(serverImports)
+export async function importAll() {
+    const { appDir, buildID } = (window as any).ALEPH_ENV as { appDir: string, buildID: string }
+    for (const p of serverImports.values()) {
+        await import('file://' + util.cleanPath(`${appDir}/.aleph/build-${buildID}/${p}`))
+    }
     serverImports.clear()
-    return a
 }
 
 interface ImportProps {