npm - @pradip1995/framework-compiler - Versions diffs - 0.2.0 - Mend

@pradip1995/framework-compiler 0.2.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 (3) hide show

package/bin/storefront-build.js +1016 -0
package/package.json +24 -0
package/templates/render-page.tsx +61 -0

package/bin/storefront-build.js ADDED Viewed

@@ -0,0 +1,1016 @@
+#!/usr/bin/env node
+/**
+ * storefront build — reads client config, generates manifests + Next.js app shell.
+ */
+import { mkdirSync, writeFileSync, readFileSync, cpSync, existsSync, readdirSync } from "fs"
+import { join, dirname, resolve, relative } from "path"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+const clientDir = resolve(process.cwd())
+const outDir = join(clientDir, ".generated-app")
+function loadClientTheme(clientDir) {
+  return loadClientStorefrontConfig(clientDir).theme
+}
+function loadClientStorefrontConfig(clientDir) {
+  const envPath = join(clientDir, ".env.local")
+  let envTheme = "valero"
+  if (existsSync(envPath)) {
+    const text = readFileSync(envPath, "utf8")
+    const match = text.match(/NEXT_PUBLIC_STOREFRONT_THEME=(.+)/)
+    const raw = match?.[1]?.trim().replace(/^["']|["']$/g, "") || "valero"
+    const map = { sahsha: "impulse", impulse: "impulse", valero: "valero" }
+    envTheme = map[raw] || "valero"
+  }
+  let raw = {}
+  const jsonPath = join(clientDir, "storefront.config.json")
+  const tsPath = join(clientDir, "storefront.config.ts")
+  if (existsSync(jsonPath)) {
+    raw = JSON.parse(readFileSync(jsonPath, "utf8"))
+  } else if (existsSync(tsPath)) {
+    try {
+      raw = JSON.parse(readFileSync(tsPath, "utf8"))
+    } catch {
+      raw = {}
+    }
+  }
+  const envLoaderVariant = process.env.NEXT_PUBLIC_LOADER_VARIANT?.trim()
+  const loader = {
+    enabled: raw.loader?.enabled !== false,
+    variant: envLoaderVariant || raw.loader?.variant || "spinner",
+  }
+  return {
+    theme: envTheme,
+    defaultCountryCode: raw.defaultCountryCode || "in",
+    loader,
+  }
+}
+function generateRootLayout(config) {
+  const loaderJson = JSON.stringify(config.loader)
+  return `import "@pradip1995/segment-tokens/themes/${config.theme}.css"
+import "./globals.css"
+import { LoaderProvider, GlobalLoader } from "@pradip1995/segment-loader"
+const loaderConfig = ${loaderJson} as const
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body className="min-h-screen bg-page-bg font-sans text-body antialiased">
+        <LoaderProvider config={loaderConfig}>
+          <GlobalLoader />
+          {children}
+        </LoaderProvider>
+      </body>
+    </html>
+  )
+}
+`
+}
+function main() {
+  console.log("storefront build")
+  console.log("  client:", clientDir)
+  console.log("  output:", outDir)
+  const pagesConfigPath = join(clientDir, "pages.config.json")
+  const pagesConfigTs = join(clientDir, "pages.config.ts")
+  if (!existsSync(pagesConfigPath) && !existsSync(pagesConfigTs)) {
+    console.error("Missing pages.config.json or pages.config.ts in", clientDir)
+    process.exit(1)
+  }
+  // Dynamic import of compiled config — use jiti or read JSON fallback
+  const pagesConfig = loadPagesConfig(clientDir)
+  const packages = collectPackages(pagesConfig)
+  mkdirSync(join(outDir, "generated"), { recursive: true })
+  writeFileSync(
+    join(outDir, "generated", "route.manifest.ts"),
+    generateRouteManifest(pagesConfig)
+  )
+  writeFileSync(
+    join(outDir, "generated", "pages.config.json"),
+    JSON.stringify(pagesConfig, null, 2)
+  )
+  generateRoutePages(pagesConfig, outDir, process.env.NEXT_PUBLIC_DEFAULT_REGION || "in")
+  generateRootRedirects(pagesConfig, outDir, process.env.NEXT_PUBLIC_DEFAULT_REGION || "in")
+  if (packages.segments.includes("@pradip1995/segment-google-login")) {
+    generateGoogleAuthRoutes(outDir, process.env.NEXT_PUBLIC_DEFAULT_REGION || "in")
+  }
+  // Remove legacy catch-all if present
+  const legacyCatchAll = join(outDir, "app", "[countryCode]", "[[...slug]]")
+  if (existsSync(legacyCatchAll)) {
+    cpSync(legacyCatchAll, join(outDir, ".legacy-slug-bak"), { recursive: true })
+    require("fs").rmSync(legacyCatchAll, { recursive: true, force: true })
+  }
+  writeFileSync(join(outDir, "app", "layout.tsx"), generateRootLayout(loadClientStorefrontConfig(clientDir)))
+  writeFileSync(join(outDir, "app", "globals.css"), GLOBALS_CSS)
+  writeFileSync(join(outDir, "app", "page.tsx"), ROOT_PAGE)
+  writeFileSync(join(outDir, "app", "error.tsx"), ERROR_PAGE)
+  writeFileSync(join(outDir, "middleware.ts"), MIDDLEWARE)
+  writeFileSync(join(outDir, "tailwind.config.js"), TAILWIND_CONFIG)
+  writeFileSync(join(outDir, "postcss.config.js"), POSTCSS_CONFIG)
+  writeFileSync(join(outDir, "next.config.js"), generateNextConfig(packages))
+  writeFileSync(join(outDir, "tsconfig.json"), TSCONFIG)
+  writeFileSync(join(outDir, "package.json"), generatePackageJson(packages, clientDir))
+  writeFileSync(join(outDir, ".npmrc"), "legacy-peer-deps=true\n")
+  // Copy env from client if present
+  const envLocal = join(clientDir, ".env.local")
+  if (existsSync(envLocal)) {
+    cpSync(envLocal, join(outDir, ".env.local"))
+  }
+  // Copy static assets: plugin public/ dirs, then client overrides
+  copyPublicAssets(packages, clientDir, outDir)
+  generateDynamicConfigSchema(clientDir, outDir)
+  console.log("  generated:", packages.segments.length, "segments,", packages.layouts.length, "layouts,", packages.workflows.length, "workflows")
+  console.log("Done.")
+}
+function readClientPackageJson(clientDir) {
+  const pkgPath = join(clientDir, "package.json")
+  if (!existsSync(pkgPath)) return {}
+  return JSON.parse(readFileSync(pkgPath, "utf8"))
+}
+/** Resolve npm semver from client deps, with optional file: override for local dev. */
+function resolveNpmDep(clientDeps, name, defaultVersion) {
+  const val = clientDeps[name]
+  if (typeof val === "string" && val.startsWith("file:")) {
+    return val
+  }
+  if (typeof val === "string" && val !== "workspace:*") {
+    return val
+  }
+  return defaultVersion
+}
+/** Resolve commerce-core from client package.json (semver or file: override). */
+function resolveCommerceCoreDep(_clientDir, clientDeps = {}) {
+  return resolveNpmDep(clientDeps, "@pradip1995/commerce-core", "^4.0.0")
+}
+/** Resolve installed package root from client package.json file: or node_modules paths */
+function resolvePackageRoot(clientDir, clientPkg, pkgName) {
+  const dep =
+    clientPkg.dependencies?.[pkgName] ||
+    clientPkg.devDependencies?.[pkgName]
+  if (typeof dep === "string" && dep.startsWith("file:")) {
+    const resolved = resolve(clientDir, dep.slice(5))
+    if (existsSync(resolved)) return resolved
+  }
+  const fromNodeModules = join(clientDir, "node_modules", pkgName)
+  if (existsSync(fromNodeModules)) return fromNodeModules
+  // Monorepo fallback: walk up to find storefront-components/packages/<short-name>
+  const shortName = pkgName.includes("/") ? pkgName.split("/").pop() : pkgName
+  let dir = clientDir
+  for (let depth = 0; depth < 10; depth++) {
+    const candidate = join(dir, "storefront-components", "packages", shortName)
+    if (existsSync(candidate)) return candidate
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+/** Infer @pradip1995/segment-assets sibling path from any file: segment dependency */
+function inferSegmentAssetsRoot(clientDir, clientPkg) {
+  const deps = clientPkg.dependencies || {}
+  for (const [name, depPath] of Object.entries(deps)) {
+    if (!name.startsWith("@pradip1995/segment-") || typeof depPath !== "string" || !depPath.startsWith("file:")) {
+      continue
+    }
+    const segmentRoot = resolve(clientDir, depPath.slice(5))
+    const assetsRoot = join(dirname(segmentRoot), "segment-assets")
+    if (existsSync(join(assetsRoot, "public"))) return assetsRoot
+  }
+  return null
+}
+function copyDirectoryContents(srcDir, destDir) {
+  mkdirSync(destDir, { recursive: true })
+  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+    const src = join(srcDir, entry.name)
+    const dest = join(destDir, entry.name)
+    if (entry.isDirectory()) {
+      copyDirectoryContents(src, dest)
+    } else if (entry.isFile()) {
+      cpSync(src, dest, { force: true })
+    }
+  }
+}
+/**
+ * Merge public/ folders into the generated app:
+ * 1. @pradip1995/segment-assets (shared baseline)
+ * 2. Each layout + segment package that defines public/
+ * 3. Client project public/ (brand overrides win)
+ */
+function copyPublicAssets(packages, clientDir, outDir) {
+  const clientPkg = readClientPackageJson(clientDir)
+  const outPublic = join(outDir, "public")
+  mkdirSync(outPublic, { recursive: true })
+  const sources = []
+  const assetsRoot =
+    resolvePackageRoot(clientDir, clientPkg, "@pradip1995/segment-assets") ||
+    inferSegmentAssetsRoot(clientDir, clientPkg)
+  if (assetsRoot) {
+    sources.push({ label: "@pradip1995/segment-assets", path: join(assetsRoot, "public") })
+  }
+  const pluginPackages = [
+    ...new Set([
+      ...packages.layouts,
+      ...packages.segments,
+      "@pradip1995/segment-nav",
+      "@pradip1995/segment-footer",
+      "@pradip1995/segment-promo-bar",
+    ]),
+  ].sort()
+  for (const pkgName of pluginPackages) {
+    const root = resolvePackageRoot(clientDir, clientPkg, pkgName)
+    if (!root) continue
+    sources.push({ label: pkgName, path: join(root, "public") })
+  }
+  let copied = 0
+  for (const source of sources) {
+    if (!existsSync(source.path)) continue
+    copyDirectoryContents(source.path, outPublic)
+    copied++
+    console.log("  assets:", relative(clientDir, source.path), `(${source.label})`)
+  }
+  const clientPublic = join(clientDir, "public")
+  if (existsSync(clientPublic)) {
+    copyDirectoryContents(clientPublic, outPublic)
+    copied++
+    console.log("  assets:", "client public/ (overrides)")
+  }
+  if (copied === 0) {
+    console.warn("  assets: no public/ folders found — add @pradip1995/segment-assets or client public/")
+  }
+}
+function resolveDynamicConfigSchemaDir() {
+  const candidates = [
+    join(__dirname, "..", "dynamic-config-schema"),
+    join(__dirname, "..", "..", "dynamic-config-schema"),
+  ]
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, "schemas", "homepage-config.json"))) return candidate
+  }
+  let dir = dirname(__dirname)
+  for (let depth = 0; depth < 6; depth++) {
+    const candidate = join(dir, "packages", "dynamic-config-schema")
+    if (existsSync(join(candidate, "schemas", "homepage-config.json"))) return candidate
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+/**
+ * Emit Medusa dynamic-config schema for backend registration.
+ * Output: dynamic-config.generated.json with { configs: { "homepage-config": ... } }
+ *
+ * Client override: place dynamic-config.schema.json in client root (full { configs } or bare config map).
+ */
+function generateDynamicConfigSchema(clientDir, outDir) {
+  const clientOverride = join(clientDir, "dynamic-config.schema.json")
+  let payload
+  if (existsSync(clientOverride)) {
+    payload = JSON.parse(readFileSync(clientOverride, "utf8"))
+    if (!payload.configs) {
+      payload = { configs: payload }
+    }
+    console.log("  dynamic-config: using client dynamic-config.schema.json")
+  } else {
+    const schemaDir = resolveDynamicConfigSchemaDir()
+    if (!schemaDir) {
+      console.warn("  dynamic-config: schema package not found — skip generation")
+      return
+    }
+    const homepage = JSON.parse(
+      readFileSync(join(schemaDir, "schemas", "homepage-config.json"), "utf8")
+    )
+    payload = { configs: { "homepage-config": homepage } }
+    console.log("  dynamic-config: from packages/dynamic-config-schema")
+  }
+  const schemaDir = resolveDynamicConfigSchemaDir()
+  const homepageSchema = payload.configs?.["homepage-config"]
+  let homepageDefaults = {}
+  if (homepageSchema && schemaDir) {
+    const { buildHomepageConfigDefaults } = require(join(schemaDir, "build-defaults.js"))
+    homepageDefaults = buildHomepageConfigDefaults(homepageSchema)
+  }
+  payload.defaults = {
+    ...(payload.defaults || {}),
+    "homepage-config": homepageDefaults,
+  }
+  const json = `${JSON.stringify(payload, null, 2)}\n`
+  writeFileSync(join(clientDir, "dynamic-config.generated.json"), json)
+  writeFileSync(join(outDir, "dynamic-config.generated.json"), json)
+  const defaultsJson = `${JSON.stringify({ "homepage-config": homepageDefaults }, null, 2)}\n`
+  writeFileSync(join(clientDir, "dynamic-config.defaults.json"), defaultsJson)
+  writeFileSync(join(outDir, "dynamic-config.defaults.json"), defaultsJson)
+  console.log("  dynamic-config: wrote dynamic-config.generated.json")
+  console.log("  dynamic-config: wrote dynamic-config.defaults.json")
+}
+function loadPagesConfig(clientDir) {
+  const jsonPath = join(clientDir, "pages.config.json")
+  if (existsSync(jsonPath)) {
+    return JSON.parse(readFileSync(jsonPath, "utf8"))
+  }
+  // Fallback: require transpiled config
+  try {
+    const jiti = require("jiti")(clientDir, { interopDefault: true })
+    return jiti("./pages.config.ts")
+  } catch {
+    console.error("Install jiti or provide pages.config.json")
+    process.exit(1)
+  }
+}
+function packageBaseName(pkg) {
+  if (!pkg.includes("/")) return pkg
+  const parts = pkg.split("/")
+  if (parts[0].startsWith("@") && parts.length >= 2) {
+    return `${parts[0]}/${parts[1]}`
+  }
+  return pkg
+}
+function collectPackages(pages) {
+  const segments = new Set()
+  const layouts = new Set()
+  const workflows = new Set()
+  for (const page of pages) {
+    workflows.add(page.workflow)
+    layouts.add(packageBaseName(page.layout))
+    for (const s of page.segments) segments.add(s)
+  }
+  // Transitive segment dependencies
+  if (segments.has("@pradip1995/segment-product-grid")) {
+    segments.add("@pradip1995/segment-product-card")
+  }
+  if (
+    segments.has("@pradip1995/segment-new-arrivals") ||
+    segments.has("@pradip1995/segment-loved-by-moms") ||
+    segments.has("@pradip1995/segment-bestsellers-carousel") ||
+    segments.has("@pradip1995/segment-collections-showcase")
+  ) {
+    segments.add("@pradip1995/segment-product-card")
+  }
+  return {
+    segments: [...segments],
+    layouts: [...layouts],
+    workflows: [...workflows],
+  }
+}
+function routeToAppPath(route, region = "in") {
+  if (route === "/") return join("app", region, "page.tsx")
+  if (route.endsWith("/*")) {
+    const base = route.slice(0, -2).replace(/^\//, "")
+    return join("app", region, base, "[[...path]]", "page.tsx")
+  }
+  const segments = route.replace(/^\//, "").split("/")
+  return join("app", region, ...segments, "page.tsx")
+}
+function generateRoutePages(pagesConfig, outDir, region = "in") {
+  for (const page of pagesConfig) {
+    const appPath = routeToAppPath(page.route, region)
+    const fullPath = join(outDir, appPath)
+    mkdirSync(dirname(fullPath), { recursive: true })
+    const workflowPkg = page.workflow
+    const layoutPkg = page.layout
+    const segmentImports = page.segments.map((s) => {
+      const name = s.replace("@pradip1995/", "").replace(/-/g, "_")
+      return { pkg: s, name }
+    })
+    let slugCode = "[]"
+    if (page.route === "/") {
+      slugCode = "[]"
+    } else if (page.route.includes("[handle]")) {
+      slugCode = '`products/${params.handle}`'.replace("params.handle", "${params.handle}")
+      slugCode = '["products", params.handle].filter(Boolean) as string[]'
+    } else if (page.route.includes("[id]")) {
+      slugCode = '["orders", params.id].filter(Boolean) as string[]'
+    } else if (page.route.endsWith("/*")) {
+      slugCode = '["account", ...(params.path ? (Array.isArray(params.path) ? params.path : [params.path]) : [])]'
+    } else {
+      const parts = page.route.replace(/^\//, "").split("/")
+      slugCode = `[${parts.map((p) => `"${p}"`).join(", ")}]`
+    }
+    const content = `import { renderConfiguredPage } from "@pradip1995/framework-runtime"
+import workflow from "${workflowPkg}"
+import Layout from "${layoutPkg}"
+${segmentImports.map((s) => `import ${s.name} from "${s.pkg}"`).join("\n")}
+export const dynamic = "force-dynamic"
+const pageConfig = {
+  workflow,
+  layout: Layout,
+  segments: [
+${segmentImports.map((s) => `    { pkg: "${s.pkg}", Component: ${s.name} },`).join("\n")}
+  ],
+}
+export default async function Page(props: {
+  params: Promise<Record<string, string | string[] | undefined>>
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  const params = await props.params
+  const searchParams = await props.searchParams
+  const countryCode = "${region}"
+  const slug = ${slugCode}
+  return renderConfiguredPage({
+    page: pageConfig,
+    countryCode,
+    slug,
+    searchParams,
+  })
+}
+`
+    writeFileSync(fullPath, content)
+  }
+}
+function searchParamsRedirectHelper() {
+  return `  const sp = await searchParams
+  const qs = new URLSearchParams()
+  for (const [key, value] of Object.entries(sp)) {
+    if (Array.isArray(value)) {
+      value.forEach((v) => qs.append(key, v))
+    } else if (value != null) {
+      qs.set(key, value)
+    }
+  }
+  const query = qs.toString()`
+}
+function generateStaticRedirectPage(route, region) {
+  return `import { redirect } from "next/navigation"
+const REGION = process.env.NEXT_PUBLIC_DEFAULT_REGION || "${region}"
+export default async function Page({
+  searchParams,
+}: {
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+${searchParamsRedirectHelper()}
+  redirect(\`/\${REGION}${route}\${query ? \`?\${query}\` : ""}\`)
+}
+`
+}
+function generateGoogleAuthRoutes(outDir, region = "in") {
+  const callbackPage = `"use client"
+import { GoogleCallbackPage } from "@pradip1995/commerce-auth"
+import {
+  handleGoogleAuthCallback,
+  handleGoogleCallback,
+} from "@pradip1995/commerce-core/data/customer"
+export default function GoogleCallbackRoute() {
+  return (
+    <GoogleCallbackPage
+      handleAuthCallback={handleGoogleAuthCallback}
+      handleCustomerCallback={handleGoogleCallback}
+    />
+  )
+}
+`
+  const regionPath = join(outDir, "app", region, "auth", "customer", "google", "callback", "page.tsx")
+  mkdirSync(dirname(regionPath), { recursive: true })
+  writeFileSync(regionPath, callbackPage)
+  const rootRedirect = `import { redirect } from "next/navigation"
+const REGION = process.env.NEXT_PUBLIC_DEFAULT_REGION || "${region}"
+export default async function Page({
+  searchParams,
+}: {
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  const sp = await searchParams
+  const qs = new URLSearchParams()
+  for (const [key, value] of Object.entries(sp)) {
+    if (Array.isArray(value)) {
+      value.forEach((v) => qs.append(key, v))
+    } else if (value != null) {
+      qs.set(key, value)
+    }
+  }
+  const query = qs.toString()
+  redirect(\`/\${REGION}/auth/customer/google/callback\${query ? \`?\${query}\` : ""}\`)
+}
+`
+  const rootPath = join(outDir, "app", "auth", "customer", "google", "callback", "page.tsx")
+  mkdirSync(dirname(rootPath), { recursive: true })
+  writeFileSync(rootPath, rootRedirect)
+}
+function generateDynamicRedirectPage(base, param, region) {
+  return `import { redirect } from "next/navigation"
+const REGION = process.env.NEXT_PUBLIC_DEFAULT_REGION || "${region}"
+export default async function Page({
+  params,
+  searchParams,
+}: {
+  params: Promise<Record<string, string | undefined>>
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  const { ${param} } = await params
+${searchParamsRedirectHelper()}
+  redirect(\`/\${REGION}/${base}/\${${param}}\${query ? \`?\${query}\` : ""}\`)
+}
+`
+}
+function generateCatchAllRedirectPage(base, region) {
+  return `import { redirect } from "next/navigation"
+const REGION = process.env.NEXT_PUBLIC_DEFAULT_REGION || "${region}"
+export default async function Page({
+  params,
+  searchParams,
+}: {
+  params: Promise<{ path?: string[] }>
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  const { path } = await params
+  const subpath = path?.length ? \`/\${path.join("/")}\` : ""
+${searchParamsRedirectHelper()}
+  redirect(\`/\${REGION}/${base}\${subpath}\${query ? \`?\${query}\` : ""}\`)
+}
+`
+}
+/** Region-less URLs (/cart) → /{region}/cart for direct links and client nav */
+function generateRootRedirects(pagesConfig, outDir, region = "in") {
+  for (const page of pagesConfig) {
+    if (page.route === "/") continue
+    if (page.route.endsWith("/*")) {
+      const base = page.route.slice(0, -2).replace(/^\//, "")
+      const fullPath = join(outDir, "app", base, "[[...path]]", "page.tsx")
+      mkdirSync(dirname(fullPath), { recursive: true })
+      writeFileSync(fullPath, generateCatchAllRedirectPage(base, region))
+      continue
+    }
+    if (page.route.includes("[handle]")) {
+      const fullPath = join(outDir, "app", "products", "[handle]", "page.tsx")
+      mkdirSync(dirname(fullPath), { recursive: true })
+      writeFileSync(fullPath, generateDynamicRedirectPage("products", "handle", region))
+      continue
+    }
+    if (page.route.includes("[id]")) {
+      const fullPath = join(outDir, "app", "orders", "[id]", "page.tsx")
+      mkdirSync(dirname(fullPath), { recursive: true })
+      writeFileSync(fullPath, generateDynamicRedirectPage("orders", "id", region))
+      continue
+    }
+    const segments = page.route.replace(/^\//, "").split("/")
+    const fullPath = join(outDir, "app", ...segments, "page.tsx")
+    mkdirSync(dirname(fullPath), { recursive: true })
+    writeFileSync(fullPath, generateStaticRedirectPage(page.route, region))
+  }
+}
+function generateRouteManifest(pages) {
+  return `export const routeManifest = ${JSON.stringify(pages, null, 2)} as const
+export type RouteManifest = typeof routeManifest
+`
+}
+function generateImportMap(packages) {
+  const all = [...packages.workflows, ...packages.layouts, ...packages.segments]
+  const entries = all
+    .map((pkg, i) => {
+      const key = pkg.replace(/[@/]/g, "_").replace(/-/g, "_")
+      return `  "${pkg}": () => import("${pkg}"),`
+    })
+    .join("\n")
+  return `export const importMap: Record<string, () => Promise<{ default: unknown }>> = {
+${entries}
+}
+export async function resolvePlugin(pkg: string) {
+  const loader = importMap[pkg]
+  if (!loader) throw new Error(\`Plugin not in import map: \${pkg}\`)
+  return loader()
+}
+`
+}
+function generatePackageJson(packages, clientDir) {
+  const clientPkg = existsSync(join(clientDir, "package.json"))
+    ? JSON.parse(readFileSync(join(clientDir, "package.json"), "utf8"))
+    : {}
+  const clientDeps = clientPkg.dependencies || {}
+  const deps = {
+    next: "15.3.8",
+    react: "19.0.3",
+    "react-dom": "19.0.3",
+    tailwindcss: clientDeps.tailwindcss || "^3.4.17",
+    postcss: clientDeps.postcss || "^8.4.49",
+    autoprefixer: clientDeps.autoprefixer || "^10.4.20",
+    color: "^5.0.3",
+    lodash: "^4.17.21",
+    qs: "^6.12.1",
+    "server-only": "^0.0.1",
+  }
+  const frameworkPkgNames = [
+    "@pradip1995/plugin-sdk",
+    "@pradip1995/framework-core",
+    "@pradip1995/framework-runtime",
+    "@pradip1995/medusa-connector",
+    "@pradip1995/workflow-home",
+    "@pradip1995/workflow-layout",
+    "@pradip1995/workflow-store",
+    "@pradip1995/workflow-product",
+    "@pradip1995/workflow-cart",
+    "@pradip1995/workflow-checkout",
+    "@pradip1995/workflow-account",
+    "@pradip1995/workflow-order",
+    "@pradip1995/workflow-wishlist",
+    "@pradip1995/workflow-help",
+  ]
+  for (const name of frameworkPkgNames) {
+    deps[name] = resolveNpmDep(clientDeps, name, "^0.2.0")
+  }
+  deps["@pradip1995/commerce-core"] = resolveCommerceCoreDep(clientDir, clientDeps)
+  deps["@medusajs/js-sdk"] = "^2.8.0"
+  deps["@medusajs/types"] = "^2.8.0"
+  // Always include tokens/primitives/loader for layout CSS and global loader
+  for (const pkg of [
+    "@pradip1995/segment-tokens",
+    "@pradip1995/segment-primitives",
+    "@pradip1995/segment-loader",
+    "@pradip1995/segment-nav",
+    "@pradip1995/segment-footer",
+    "@pradip1995/segment-promo-bar",
+    "@pradip1995/segment-product-card",
+  ]) {
+    if (clientDeps[pkg]) {
+      deps[pkg] = resolveNpmDep(clientDeps, pkg, "^0.2.0")
+    }
+  }
+  for (const pkg of [...packages.workflows, ...packages.layouts, ...packages.segments]) {
+    if (frameworkPkgNames.includes(pkg)) continue
+    if (clientDeps[pkg]) {
+      deps[pkg] = resolveNpmDep(clientDeps, pkg, "^0.2.0")
+    }
+  }
+  if (packages.segments.includes("@pradip1995/segment-google-login")) {
+    deps["@pradip1995/commerce-auth"] = resolveNpmDep(clientDeps, "@pradip1995/commerce-auth", "^4.0.0")
+  }
+  return JSON.stringify(
+    {
+      name: "generated-storefront",
+      private: true,
+      scripts: {
+        dev: "next dev",
+        build: "next build",
+        start: "next start",
+      },
+      dependencies: deps,
+      devDependencies: {
+        "@types/node": "^22",
+        "@types/react": "^19",
+        "@types/react-dom": "^19",
+        typescript: "^5.7.2",
+      },
+    },
+    null,
+    2
+  )
+}
+const ROOT_LAYOUT = `import "@pradip1995/segment-tokens/theme.css"
+import "./globals.css"
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body className="min-h-screen">{children}</body>
+    </html>
+  )
+}
+`
+const GLOBALS_CSS = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`
+const TAILWIND_CONFIG = `/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./app/**/*.{js,ts,jsx,tsx}",
+    "./node_modules/@pradip1995/segment-*/src/**/*.{js,ts,jsx,tsx}",
+    "./node_modules/@pradip1995/layout-*/src/**/*.{js,ts,jsx,tsx}",
+    "./node_modules/@pradip1995/segment-primitives/src/**/*.{js,ts,jsx,tsx}",
+    "./node_modules/@pradip1995/commerce-core/src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        page: { bg: "var(--color-page-bg)" },
+        surface: { DEFAULT: "var(--color-surface)", muted: "var(--color-surface-muted)" },
+        hero: { fallback: "var(--color-hero-fallback)" },
+        heading: { DEFAULT: "var(--color-text-heading)", sub: "var(--color-text-subheading)" },
+        brand: {
+          accent: "var(--color-brand-accent)",
+          "accent-hover": "var(--color-brand-accent-hover)",
+          pink: "var(--color-brand-pink)",
+          primary: "var(--color-brand-primary)",
+          sale: "var(--color-brand-sale)",
+          success: "var(--color-brand-success)",
+          footer: "var(--color-footer-bg)",
+        },
+        body: "var(--color-text-body)",
+        muted: "var(--color-text-muted)",
+        inverse: "var(--color-text-inverse)",
+      },
+      fontFamily: {
+        sans: ["var(--font-sans)"],
+        heading: ["var(--font-heading)"],
+        display: ["var(--font-display)"],
+        quote: ["var(--font-quote)"],
+      },
+      lineHeight: {
+        heading: "var(--line-height-heading)",
+        body: "var(--line-height-body)",
+      },
+      letterSpacing: {
+        nav: "var(--letter-spacing-nav)",
+      },
+      borderColor: {
+        "cart-border": "var(--color-border)",
+      },
+      boxShadow: {
+        brand: "var(--shadow-brand)",
+        "brand-sm": "var(--shadow-brand-sm)",
+        card: "var(--shadow-card)",
+      },
+      backgroundImage: {
+        "promo-gradient": "var(--gradient-promo)",
+        "hero-gradient": "var(--gradient-hero)",
+      },
+    },
+  },
+  plugins: [],
+}
+`
+const POSTCSS_CONFIG = `module.exports = {
+  plugins: { tailwindcss: {}, autoprefixer: {} },
+}
+`
+const CATCH_ALL_PAGE = `import { renderPage } from "@pradip1995/framework-runtime"
+import { routeManifest } from "@generated/route.manifest"
+import { importMap } from "@generated/import-map"
+export const dynamic = "force-dynamic"
+export default async function Page(props: {
+  params: Promise<{ countryCode: string; slug?: string[] }>
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  const params = await props.params
+  const searchParams = await props.searchParams
+  return renderPage({
+    countryCode: params.countryCode,
+    slug: params.slug ?? [],
+    searchParams,
+    routeManifest: routeManifest as import("@pradip1995/plugin-sdk").PageConfigEntry[],
+    importMap,
+  })
+}
+`
+const ROOT_PAGE = `import { redirect } from "next/navigation"
+export default function RootPage() {
+  redirect(\`/\${process.env.NEXT_PUBLIC_DEFAULT_REGION || "in"}\`)
+}
+`
+const MIDDLEWARE = `import { NextRequest, NextResponse } from "next/server"
+const DEFAULT_REGION = process.env.NEXT_PUBLIC_DEFAULT_REGION || "in"
+/** Paths served under /{region}/… in the generated app */
+const REGION_SCOPED = new Set([
+  "store",
+  "cart",
+  "checkout",
+  "account",
+  "products",
+  "orders",
+  "collections",
+  "auth",
+])
+function isRegionCode(segment: string) {
+  return segment.length >= 2 && segment.length <= 3 && /^[a-z]{2,3}$/i.test(segment)
+}
+export async function middleware(request: NextRequest) {
+  const pathname = request.nextUrl.pathname
+  if (pathname.includes(".") || pathname.startsWith("/api") || pathname.startsWith("/_next")) {
+    return NextResponse.next()
+  }
+  const segments = pathname.split("/").filter(Boolean)
+  const firstSegment = segments[0]?.toLowerCase() ?? ""
+  if (pathname === "/" || !firstSegment) {
+    return NextResponse.redirect(new URL(\`/\${DEFAULT_REGION}\`, request.url))
+  }
+  if (isRegionCode(firstSegment)) {
+    return NextResponse.next()
+  }
+  if (REGION_SCOPED.has(firstSegment)) {
+    const url = request.nextUrl.clone()
+    url.pathname = \`/\${DEFAULT_REGION}\${pathname}\`
+    return NextResponse.redirect(url)
+  }
+  return NextResponse.next()
+}
+export const config = {
+  matcher: ["/((?!api|_next/static|_next/image|favicon.ico).*)"],
+}
+`
+const ERROR_PAGE = `"use client"
+export default function Error({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string }
+  reset: () => void
+}) {
+  return (
+    <main className="min-h-screen p-8">
+      <h2 className="text-xl font-semibold mb-2">Something went wrong</h2>
+      <p className="text-sm text-muted mb-4">{error.message}</p>
+      <button type="button" onClick={() => reset()} className="px-4 py-2 bg-brand-accent text-inverse text-sm">
+        Try again
+      </button>
+    </main>
+  )
+}
+`
+function generateNextConfig(packages) {
+  const uiPackages = [
+    ...packages.workflows,
+    ...packages.layouts,
+    ...packages.segments,
+    "@pradip1995/segment-nav",
+    "@pradip1995/segment-footer",
+    "@pradip1995/segment-promo-bar",
+    "@pradip1995/segment-primitives",
+    "@pradip1995/segment-tokens",
+    "@pradip1995/framework-runtime",
+    "@pradip1995/framework-core",
+    "@pradip1995/plugin-sdk",
+    "@pradip1995/medusa-connector",
+    "@pradip1995/commerce-core",
+  ]
+  if (packages.segments.includes("@pradip1995/segment-google-login")) {
+    uiPackages.push("@pradip1995/commerce-auth")
+  }
+  const transpile = [...new Set(uiPackages)]
+  return `const path = require("path")
+/** @type {import('next').NextConfig} */
+module.exports = {
+  transpilePackages: ${JSON.stringify(transpile, null, 4)},
+  images: { remotePatterns: [{ protocol: "https", hostname: "**" }] },
+  webpack: (config) => {
+    config.resolve.modules = [
+      path.resolve(__dirname, "node_modules"),
+      ...(config.resolve.modules || []),
+    ]
+    try {
+      const commerceCoreEntry = require.resolve("@pradip1995/commerce-core/config")
+      config.resolve.alias = {
+        ...config.resolve.alias,
+        "@core": path.dirname(commerceCoreEntry),
+      }
+    } catch {}
+    return config
+  },
+}
+`
+}
+const NEXT_CONFIG = generateNextConfig({ workflows: [], layouts: [], segments: [] })
+const TSCONFIG = JSON.stringify(
+  {
+    compilerOptions: {
+      target: "ES2022",
+      lib: ["dom", "dom.iterable", "esnext"],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: "esnext",
+      moduleResolution: "bundler",
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: "preserve",
+      incremental: true,
+      plugins: [{ name: "next" }],
+      paths: {
+        "@generated/*": ["./generated/*"],
+      },
+    },
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+    exclude: ["node_modules"],
+  },
+  null,
+  2
+)
+main()

package/package.json ADDED Viewed

@@ -0,0 +1,24 @@
+{
+  "name": "@pradip1995/framework-compiler",
+  "version": "0.2.0",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "storefront-build": "./bin/storefront-build.js"
+  },
+  "files": [
+    "bin",
+    "templates"
+  ],
+  "dependencies": {
+    "jiti": "^2.4.2"
+  },
+  "scripts": {
+    "build": "echo ok",
+    "typecheck": "echo ok",
+    "lint": "echo ok"
+  }
+}

package/templates/render-page.tsx ADDED Viewed

@@ -0,0 +1,61 @@
+import { matchRoute, buildRouteContext, container } from "@pradip1995/framework-core"
+import { resolvePlugin } from "@generated/import-map"
+import { routeManifest } from "@generated/route.manifest"
+import { registerServices } from "./register-services"
+import { getSegmentProps } from "./segment-props"
+import type { ComponentType } from "react"
+type RenderPageInput = {
+  countryCode: string
+  slug: string[]
+  searchParams: Record<string, string | string[] | undefined>
+}
+export async function renderPage(input: RenderPageInput) {
+  registerServices()
+  const pathname =
+    input.slug.length > 0 ? `/${input.slug.join("/")}` : "/"
+  const page = matchRoute(routeManifest as Parameters<typeof matchRoute>[0], pathname)
+  if (!page) {
+    const { notFound } = await import("next/navigation")
+    notFound()
+  }
+  const route = buildRouteContext(input.countryCode, input.slug, input.searchParams)
+  const workflowMod = (await resolvePlugin(page!.workflow)) as {
+    default: { execute: (ctx: unknown) => Promise<Record<string, unknown>> }
+  }
+  const services: Record<string, unknown> = {}
+  for (const [key] of container["factories"] ?? new Map()) {
+    if (container.has(key)) {
+      services[key] = container.resolve(key)
+    }
+  }
+  const data = await workflowMod.default.execute({ route, services })
+  const layoutMod = (await resolvePlugin(page!.layout)) as {
+    default: ComponentType<{ data: Record<string, unknown>; children: React.ReactNode }>
+  }
+  const Layout = layoutMod.default
+  const segmentElements = await Promise.all(
+    page!.segments.map(async (segmentPkg) => {
+      const mod = (await resolvePlugin(segmentPkg)) as {
+        default: ComponentType<Record<string, unknown>>
+      }
+      const props = getSegmentProps(segmentPkg, data)
+      const Segment = mod.default
+      return <Segment key={segmentPkg} {...props} />
+    })
+  )
+  return (
+    <Layout data={data}>
+      {segmentElements}
+    </Layout>
+  )
+}