npm - @inglorious/ssx - Versions diffs - 1.9.0 → 1.10.0 - Mend

@inglorious/ssx 1.9.0 → 1.10.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 (11) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/ssx",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Server-Side-X. Xecution? Xperience? Who knows.",
   "author": "IceOnFire <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -48,6 +48,7 @@
   },
   "sideEffects": false,
   "dependencies": {
+    "@inglorious/logo": "^2.1.0",
     "@lit-labs/ssr": "^4.0.0",
     "commander": "^14.0.2",
     "connect": "^3.7.0",

package/src/build/build.test.js CHANGED Viewed

@@ -56,7 +56,12 @@ describe("build", () => {
     loadManifest.mockResolvedValue(null) // First build
     getPages.mockResolvedValue([{ path: "/" }])
     hashEntities.mockResolvedValue("hash")
-    generateStore.mockResolvedValue({})
+    generateStore.mockResolvedValue({
+      store: {},
+      entities: {},
+      hasTypesFile: false,
+      hasEntitiesFile: false,
+    })
     generatePages
       .mockResolvedValueOnce([{ path: "/", html: "<html></html>" }])
       .mockResolvedValueOnce([])

package/src/build/index.js CHANGED Viewed

@@ -140,7 +140,11 @@ export async function build(options = {}) {
   // 8. Always regenerate client-side JavaScript (it's cheap and ensures consistency)
   console.log("\n📝 Generating client scripts...\n")
-  const app = generateApp(allPages, { ...mergedOptions, isDev: false })
+  const app = await generateApp(
+    allPages,
+    { ...mergedOptions, isDev: false },
+    loader,
+  )
   await fs.writeFile(path.join(outDir, "main.js"), app, "utf-8")
   console.log(`  ✓ main.js\n`)

package/src/build/pages.js CHANGED Viewed

@@ -14,11 +14,16 @@ import { extractPageMetadata } from "./metadata.js"
  * @param {Object} [options] - Generation options.
  * @param {boolean} [options.shouldGenerateHtml=true] - Whether to generate HTML.
  * @param {boolean} [options.shouldGenerateMetadata=true] - Whether to generate metadata.
+ * @param {Object} [options.originalEntities] - Original entities from entities.js.
  * @param {Function} [loader] - Optional loader function.
  * @returns {Promise<Array<Object>>} The processed pages with `html` and `metadata` properties added.
  */
 export async function generatePages(store, pages, options = {}, loader) {
-  const { shouldGenerateHtml = true, shouldGenerateMetadata = true } = options
+  const {
+    shouldGenerateHtml = true,
+    shouldGenerateMetadata = true,
+    originalEntities = {},
+  } = options
   const load = loader || ((p) => import(pathToFileURL(path.resolve(p))))
   const api = store._api
@@ -43,6 +48,7 @@ export async function generatePages(store, pages, options = {}, loader) {
     if (shouldGenerateHtml) {
       const html = await renderPage(store, page, entity, {
         ...options,
+        originalEntities,
         wrap: true,
       })
       page.html = html

package/src/dev/index.js CHANGED Viewed

@@ -80,7 +80,11 @@ export async function dev(options = {}) {
       }
       // Generate and update the virtual app file BEFORE rendering
-      const app = generateApp(pages, { ...mergedOptions, isDev: true })
+      const app = await generateApp(
+        pages,
+        { ...mergedOptions, isDev: true },
+        loader,
+      )
       virtualFiles.set("/main.js", app)
       // Invalidate the virtual module to ensure Vite picks up changes

package/src/render/html.js CHANGED Viewed

@@ -41,10 +41,10 @@ export async function toHTML(store, renderFn, options = {}) {
   const layout = options.layout ?? defaultLayout
   let html = layout(finalHTML, options)
-  if (options.ssxEntity) {
+  if (options.ssxPage) {
     html = html.replace(
       /<body[^>]*>/,
-      `$&<script type="application/json" id="__SSX_ENTITY__">${JSON.stringify(options.ssxEntity)}</script>`,
+      `$&<script type="application/json" id="__SSX_PAGE__">${JSON.stringify(options.ssxPage)}</script>`,
     )
   }

package/src/render/index.js CHANGED Viewed

@@ -52,6 +52,6 @@ export async function renderPage(store, page, entity, options = {}) {
     styles,
     head,
     scripts,
-    ssxEntity: { [moduleName]: entity },
+    ssxPage: { [moduleName]: entity },
   })
 }

package/src/scripts/app.js CHANGED Viewed

@@ -1,15 +1,24 @@
+import { getStoreStuff } from "../store/stuff.js"
 /**
  * Generates the client-side entry point script.
  * This script hydrates the store with the initial state (entities) and sets up the router.
  *
  * @param {Array<Object>} pages - List of page objects to generate routes for.
  * @param {Object} [options] - Runtime options.
+ * @param {boolean} [options.hasTypesFile] - Whether src/store/types.js exists.
+ * @param {boolean} [options.hasEntitiesFile] - Whether src/store/entities.js exists.
  * @returns {string} The generated JavaScript code for the client entry point.
  */
-export function generateApp(pages, options = {}) {
+export async function generateApp(pages, options = {}, loader) {
   const i18n = options.i18n || inferI18nFromPages(pages)
   const isDev = Boolean(options.isDev)
+  const types = await getStoreStuff("types", options, loader)
+  const hasTypesFile = Object.keys(types).length
+  const entities = await getStoreStuff("entities", options, loader)
+  const hasEntitiesFile = Object.keys(entities).length
   // Build client route map, including localized patterns (e.g. /it/about).
   const routesByPattern = new Map()
   for (const page of pages) {
@@ -22,11 +31,30 @@ export function generateApp(pages, options = {}) {
   }
   const routes = [...routesByPattern.values()]
+  const typesImport = hasTypesFile
+    ? `import { types as additionalTypes } from "@/store/types.js"`
+    : ""
+  const entitiesImport = hasEntitiesFile
+    ? `import { entities as additionalEntities } from "@/store/entities.js"`
+    : ""
+  const typesAssignment = hasTypesFile
+    ? `Object.assign(types, additionalTypes)`
+    : ""
+  const entitiesAssignment = hasEntitiesFile
+    ? `Object.assign(entities, additionalEntities)`
+    : ""
   return `import "@inglorious/web/hydrate"
 import { createDevtools, createStore, mount } from "@inglorious/web"
 import { getRoute, router, setRoutes } from "@inglorious/web/router"
 import { getLocaleFromPath } from "@inglorious/ssx/i18n"
+${typesImport}
+${entitiesImport}
 const normalizePathname = (path = "/") => path.split("?")[0].split("#")[0]
 const normalizeRoutePath = (path = "/") => {
   const pathname = normalizePathname(path)
@@ -50,24 +78,18 @@ const path = normalizeRoutePath(window.location.pathname)
 const page = pages.find((page) => normalizeRoutePath(page.path) === path)
 const types = { router }
+${typesAssignment}
 const i18n = ${JSON.stringify(i18n, null, 2)}
 const isDev = ${JSON.stringify(isDev)}
-const ssxEntity = JSON.parse(document.getElementById("__SSX_ENTITY__").textContent)
 const entities = {
-  router: {
-    type: "router",
-    path,
-    route: page?.moduleName,
-  },
-  i18n: {
-    type: "i18n",
-    ...i18n,
-  },
-  ...ssxEntity,
+  router: { type: "router", path, route: page?.moduleName },
+  i18n: { type: "i18n", ...i18n },
 }
+${entitiesAssignment}
+Object.assign(entities, JSON.parse(document.getElementById("__SSX_PAGE__").textContent))
 const middlewares = []
 if (isDev) {

package/src/scripts/app.test.js CHANGED Viewed

@@ -75,7 +75,7 @@ describe("generateApp", () => {
       { ...page, path: "/pt/hello", locale: "pt" },
     ]
-    const app = generateApp(localizedPages)
+    const app = await generateApp(localizedPages)
     expect(app).toContain(`"/hello": () => import("@/pages/hello.js")`)
     expect(app).toContain(`"/it/hello": () => import("@/pages/hello.js")`)

package/src/store/index.js CHANGED Viewed

@@ -1,15 +1,15 @@
-import { existsSync } from "node:fs"
-import path from "node:path"
 import { pathToFileURL } from "node:url"
 import { createStore } from "@inglorious/web"
 import { getModuleName } from "../utils/module.js"
+import { getStoreStuff } from "./stuff.js"
 /**
  * Generates the application store based on the provided pages and configuration.
  * It loads page modules to register their exported entities as store types.
- * It also attempts to load initial entities from an `entities.js` file in the root directory.
+ * It also attempts to load initial entities from an `entities.js` file and
+ * additional types from a `types.js` file in the store directory.
  *
  * @param {Array<Object>} pages - List of page objects containing file paths.
  * @param {Object} options - Configuration options.
@@ -18,34 +18,17 @@ import { getModuleName } from "../utils/module.js"
  * @returns {Promise<Object>} The initialized store instance.
  */
 export async function generateStore(pages = [], options = {}, loader) {
-  const { rootDir = "." } = options
-  const srcDir = path.join(rootDir, "src")
   const load = loader || ((p) => import(pathToFileURL(p)))
-  const types = {}
+  const types = await getStoreStuff("types", options, loader)
   for (const page of pages) {
     const pageModule = await load(page.filePath)
     const name = getModuleName(pageModule)
     types[name] = pageModule[name]
   }
-  let entities = {}
-  const extensions = ["js", "ts"]
-  for (const ext of extensions) {
-    const fullPath = path.join(srcDir, "store", `entities.${ext}`)
-    if (existsSync(fullPath)) {
-      try {
-        const module = await load(fullPath)
-        entities = module.entities
-        break
-      } catch {
-        // ignore and try next extension
-      }
-    }
-  }
+  const entities = await getStoreStuff("entities", options, loader)
   const store = createStore({ types, entities, autoCreateEntities: true })
   return store

package/src/store/stuff.js ADDED Viewed

@@ -0,0 +1,87 @@
+import { existsSync } from "node:fs"
+import path from "node:path"
+import { pathToFileURL } from "node:url"
+export async function getStoreStuff(name, options, loader) {
+  const { rootDir = "." } = options
+  const srcDir = path.join(rootDir, "src")
+  const load = loader || ((p) => import(pathToFileURL(p)))
+  const stuff = {}
+  const extensions = ["js", "ts"]
+  for (const ext of extensions) {
+    const stuffPath = path.join(srcDir, "store", `${name}.${ext}`)
+    if (existsSync(stuffPath)) {
+      try {
+        const module = await load(stuffPath)
+        if (module[name]) {
+          Object.assign(stuff, module[name])
+        }
+        break
+      } catch {
+        // ignore and try next extension
+      }
+    }
+  }
+  return stuff
+}
+export async function getTypes(options, loader) {
+  const { rootDir = "." } = options
+  const srcDir = path.join(rootDir, "src")
+  const load = loader || ((p) => import(pathToFileURL(p)))
+  const types = {}
+  const extensions = ["js", "ts"]
+  for (const ext of extensions) {
+    const typesPath = path.join(srcDir, "store", `types.${ext}`)
+    if (existsSync(typesPath)) {
+      try {
+        const module = await load(typesPath)
+        if (module.types) {
+          Object.assign(types, module.types)
+        }
+        break
+      } catch {
+        // ignore and try next extension
+      }
+    }
+  }
+  return types
+}
+export async function getEntities(options, loader) {
+  const { rootDir = "." } = options
+  const srcDir = path.join(rootDir, "src")
+  const load = loader || ((p) => import(pathToFileURL(p)))
+  const entities = {}
+  const extensions = ["js", "ts"]
+  for (const ext of extensions) {
+    const entitiesPath = path.join(srcDir, "store", `entities.${ext}`)
+    if (existsSync(entitiesPath)) {
+      try {
+        const module = await load(entitiesPath)
+        if (module.entities) {
+          Object.assign(entities, module.entities)
+        }
+        break
+      } catch {
+        // ignore and try next extension
+      }
+    }
+  }
+  return entities
+}