@wular/coder 0.4.3 → 0.4.4

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/cli/start.js

@@ -0,0 +1,158 @@
+// @bun
+import {
+  browserHost,
+  ensurePortFree,
+  openBrowser,
+  printServerReady
+} from "../_chunks/index-q738kkhj.js";
+import {
+  bootstrapCompat
+} from "../_chunks/index-tq3b39a5.js";
+import {
+  loadConfig
+} from "../_chunks/index-71885zaq.js";
+import"../_chunks/index-bzd2ef7t.js";
+import {
+  markErrorLogged
+} from "../_chunks/index-jcsjq3d1.js";
+import {
+  buildIndexFile,
+  buildManifestFile,
+  linkStandaloneOrigins,
+  registerPrebundleResolve
+} from "../_chunks/index-hdbwtdv2.js";
+import"../_chunks/index-6kp9r0d9.js";
+import {
+  drainWorkUnits
+} from "../_chunks/index-grta8ap3.js";
+import"../_chunks/index-kresp2n8.js";
+import {
+  isPostpone
+} from "../_chunks/index-e3a6yx84.js";
+import"../_chunks/index-pym1cezq.js";
+import"../_chunks/index-jt8e1pje.js";
+import {
+  getBuildExtensions
+} from "../_chunks/index-zqpqyg8p.js";
+import"../_chunks/index-qjj6gddn.js";
+import {
+  __require
+} from "../_chunks/index-rt9qq1va.js";
+
+// src/cli/start.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+async function createRequestHandler(options = {}) {
+  registerPrebundleResolve();
+  const config = options.config ?? await loadConfig(options.root, { serve: true });
+  if (shipsElsewhere(config)) {
+    const shipped = await shippedStart(config);
+    return shipped.createRequestHandler({ root: options.root, manifest: options.manifest });
+  }
+  const { createRequestHandler: create } = await import("../_chunks/pipeline-4t9q43ht.js");
+  return create({ ...options, config });
+}
+function shipsElsewhere(config) {
+  return existsSync(buildIndexFile(config.outPath)) && !linkStandaloneOrigins(config.outPath);
+}
+function shippedStart(config) {
+  const entry = pathToFileURL(path.join(config.outPath, "server", "entry.js")).href;
+  return import(entry);
+}
+async function maybeBuiltFile(...args) {
+  const { maybeBuiltFile: impl } = await import("../_chunks/pipeline-4t9q43ht.js");
+  return impl(...args);
+}
+async function start(options = {}) {
+  const startedAt = Date.now();
+  const port = options.port ?? 3000;
+  const hostname = options.hostname ?? "0.0.0.0";
+  const config = await loadConfig(options.root, { serve: true });
+  if (shipsElsewhere(config)) {
+    await (await shippedStart(config)).start(options);
+    return;
+  }
+  await guardUnservableOutputMode(config);
+  const manifest = await readProductionManifest(config);
+  await ensurePortFree(port, hostname);
+  let handler;
+  let pending;
+  const ensureHandler = () => pending ??= createRequestHandler({ root: options.root, config, manifest }).then((ready) => {
+    handler = ready;
+    return ready;
+  });
+  const server = Bun.serve({
+    hostname,
+    port,
+    fetch: (request, server2) => handler ? handler(request, server2) : ensureHandler().then((ready) => ready(request, server2))
+  });
+  printServerReady({
+    mode: "production",
+    hostname,
+    port: server.port ?? port,
+    elapsedMs: Date.now() - startedAt
+  });
+  ensureHandler().catch(() => {
+    return;
+  });
+  openBrowser(`http://${browserHost(hostname)}:${server.port ?? port}`);
+  installShutdownHandlers(server);
+  installProcessErrorHandlers();
+  return server;
+}
+function installProcessErrorHandlers() {
+  const globalWithFlag = globalThis;
+  if (globalWithFlag.__pnextProcessErrorHandlers)
+    return;
+  globalWithFlag.__pnextProcessErrorHandlers = true;
+  const report = (reason) => {
+    if (isPostpone(reason))
+      return;
+    if (markErrorLogged(reason))
+      console.error(reason);
+  };
+  process.on("unhandledRejection", report);
+  process.on("uncaughtException", report);
+}
+async function readProductionManifest(config) {
+  try {
+    return JSON.parse(await readFile(buildManifestFile(config.outPath), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error("No production build found. Run 'pnext build' first.");
+    }
+    throw error;
+  }
+}
+async function guardUnservableOutputMode(config) {
+  await bootstrapCompat(config);
+  const mode = getBuildExtensions().compat.nextOutputMode();
+  if (mode === "export") {
+    console.error('"next start" does not work with "output: export" configuration. Use "npx serve@latest out" instead.');
+    process.exit(1);
+  }
+  if (mode === "standalone" && !process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
+    console.warn('"next start" does not work with "output: standalone" configuration. Use "node .next/standalone/server.js" instead.');
+  }
+}
+function installShutdownHandlers(server) {
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    server.stop();
+    await drainWorkUnits();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+export {
+  createRequestHandler,
+  maybeBuiltFile,
+  readProductionManifest,
+  start
+};

package/dist/dash/standalone/node_modules/@wular/pnext/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@wular/pnext",
+  "version": "0.1.8",
+  "description": "A fast little framework for server-first React apps, fully compatible with Next.js",
+  "type": "module",
+  "bin": {
+    "pnext": "bin/pnext"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/muzam1l/pnext.git"
+  },
+  "homepage": "https://github.com/muzam1l/pnext",
+  "bugs": {
+    "url": "https://github.com/muzam1l/pnext/issues"
+  },
+  "keywords": [
+    "react",
+    "preact",
+    "framework",
+    "ssr",
+    "server-components",
+    "bun",
+    "nextjs"
+  ],
+  "files": [
+    "bin",
+    "config",
+    "dist",
+    "src",
+    "tsconfig.json",
+    "reference"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": ">=1.3.10"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./internal": "./src/internal.ts",
+    "./cache": "./src/api/cache.ts",
+    "./dynamic": "./src/api/dynamic.tsx",
+    "./link": "./src/api/link.tsx",
+    "./navigation": "./src/api/navigation.ts",
+    "./navigation/client": "./src/api/client-navigation.ts",
+    "./server": "./src/api/server.ts",
+    "./config/*": "./config/*"
+  },
+  "scripts": {
+    "lint": "bun scripts/check-compat-boundary.ts && prettier --check . && eslint . --max-warnings 0 && tsc --noEmit",
+    "format": "prettier --write .",
+    "bench": "bun bench/run.ts",
+    "clean": "rm -rf .turbo .pnext node_modules",
+    "prepublishOnly": "bun run lint",
+    "prepack": "NODE_ENV=production bun scripts/prebundle.ts",
+    "postpack": "rm -rf dist",
+    "version-bump:patch": "bun scripts/bump.mjs patch",
+    "version-bump:minor": "bun scripts/bump.mjs minor",
+    "version-bump:major": "bun scripts/bump.mjs major"
+  },
+  "dependencies": {
+    "client-only": "^0.0.1",
+    "dotenv": "^16.0.3",
+    "esbuild": "^0.25.12",
+    "oxc-parser": "0.142.0",
+    "oxc-resolver": "^11.24.2",
+    "oxc-transform": "0.136.0",
+    "preact": "^10.29.2",
+    "preact-render-to-string": "^6.7.0",
+    "react-compiler-runtime": "^1.0.0",
+    "server-only": "^0.0.1",
+    "web-vitals": "^4.2.4"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.4.0",
+    "@eslint/js": "^9.38.0",
+    "@types/bun": "^1.3.0",
+    "eslint": "^9.38.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-turbo": "^2.5.8",
+    "prettier": "^3.9.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2"
+  },
+  "optionalDependencies": {
+    "@mdx-js/mdx": "^3.1.0",
+    "@opentelemetry/api": "^1.7.0",
+    "@resvg/resvg-js": "^2.6.2",
+    "@typescript/native-preview": "^7.0.0-dev.20260707.2",
+    "next-font": "^2.0.2",
+    "sass": "^1.80.0",
+    "satori": "^0.12.0",
+    "sharp": "^0.34.0"
+  }
+}

package/dist/dash/standalone/node_modules/@wular/pnext/src/api/client-navigation.ts

@@ -0,0 +1,337 @@
+import { options } from 'preact'
+import { useEffect, useState } from 'preact/hooks'
+import { ReadonlyURLSearchParams, type HrefOptions } from './navigation'
+import { blockJavascriptUrl, prefetchRoute, softNavigate } from '../client/router'
+import { routerState } from '../client/router/hub'
+import { seedHistoryEntry } from '../client/router/history'
+import {
+  emitLocationChange,
+  locationListeners,
+  scheduleNavigationScroll,
+} from '../client/router/events'
+import { routeHref } from '../routing/href'
+import type { RouteParams, RouteParamValue, RoutePath } from '../types'
+
+export type NavigateOptions<Route extends RoutePath> = HrefOptions<Route> & {
+  scroll?: boolean
+}
+
+export type PrefetchOptions<Route extends RoutePath> = HrefOptions<Route> & {
+  kind?: 'auto' | 'full'
+  onInvalidate?: () => void
+}
+
+export interface PNextRouter {
+  push<Route extends RoutePath>(
+    route: Route,
+    ...options: RouteParams<Route> extends Record<string, never>
+      ? [options?: NavigateOptions<Route>]
+      : [options: NavigateOptions<Route>]
+  ): void
+  replace<Route extends RoutePath>(
+    route: Route,
+    ...options: RouteParams<Route> extends Record<string, never>
+      ? [options?: NavigateOptions<Route>]
+      : [options: NavigateOptions<Route>]
+  ): void
+  prefetch<Route extends RoutePath>(
+    route: Route,
+    ...options: RouteParams<Route> extends Record<string, never>
+      ? [options?: PrefetchOptions<Route>]
+      : [options: PrefetchOptions<Route>]
+  ): void
+  refresh(): void
+  back(): void
+  forward(): void
+  bfcacheId: string
+}
+
+export { ReadonlyURLSearchParams }
+
+export interface CurrentRoute<Route extends RoutePath = RoutePath> {
+  route: Route | null
+  pathname: string
+  params: RouteParams<Route>
+  searchParams: ReadonlyURLSearchParams
+}
+
+interface RouteState {
+  route?: string
+  params?: Record<string, RouteParamValue>
+  catchAllOptional?: boolean
+  staticChildren?: string[]
+  bfcacheId?: string
+  /** `prefetch = 'allow-runtime'`: this route's shell is request-sampled. */
+  runtimePrefetch?: boolean
+}
+
+/**
+ * `__PNEXT_ROUTE__.route` is stored on the wire in bracket-free colon form
+ * (`/:teamSlug/:slug*`) so no `[x]`/`%5Bx%5D` placeholder ever reaches a
+ * response body. The public `useRoute()` contract exposes the familiar bracket
+ * pattern (`/[teamSlug]/[...slug]`), so convert back at the API boundary.
+ */
+function bracketRoutePattern(state: RouteState): string | null {
+  const route = state.route
+  if (route == null) return null
+  return route
+    .replace(/:([\w$]+)\*/g, state.catchAllOptional ? '[[...$1]]' : '[...$1]')
+    .replace(/:([\w$]+)/g, '[$1]')
+}
+
+declare global {
+  interface Window {
+    __PNEXT_ROUTE__?: RouteState
+    __PNEXT_HISTORY_PATCHED__?: boolean
+  }
+}
+
+// This module is the reason the hard-loaded entry needs its history ids before first render:
+// `bfcacheId` below reads them, and `patchHistory` carries them onto an app-level pushState. Seeding
+// here rather than in the hub's installRouter keeps a page whose client graph never touches router
+// state from paying for them.
+seedHistoryEntry()
+
+export function useRouter(): PNextRouter {
+  return router
+}
+
+const router: PNextRouter = {
+  push(route, ...[options]) {
+    navigate(routerHref(route, options), 'push', options?.scroll)
+  },
+  replace(route, ...[options]) {
+    navigate(routerHref(route, options), 'replace', options?.scroll)
+  },
+  prefetch(route, ...[options]) {
+    void prefetchRoute(routerHref(route, options), {
+      strict: true,
+      full: options?.kind === 'full',
+      onInvalidate: options?.onInvalidate,
+    })
+  },
+  refresh() {
+    void softNavigate(window.location.href, { replace: true, scroll: false })
+  },
+  back() {
+    window.history.back()
+  },
+  forward() {
+    window.history.forward()
+  },
+  get bfcacheId() {
+    return routeState().bfcacheId ?? ''
+  },
+}
+
+function routerHref<Route extends RoutePath>(
+  route: Route,
+  options: HrefOptions<Route> | undefined,
+) {
+  return hasHrefParts(options) ? routeHref(route, options) : String(route)
+}
+
+function hasHrefParts<Route extends RoutePath>(
+  options: HrefOptions<Route> | undefined,
+): options is HrefOptions<Route> {
+  return Boolean(options && ('params' in options || 'search' in options || 'hash' in options))
+}
+
+export function usePathname() {
+  return useLocation().pathname
+}
+
+export function useSearchParams(): ReadonlyURLSearchParams {
+  return new ReadonlyURLSearchParams(useLocation().search)
+}
+
+export function useParams<Route extends RoutePath = RoutePath>() {
+  useLocation()
+  return (routeState().params ?? {}) as RouteParams<Route>
+}
+
+export function useRoute<Route extends RoutePath = RoutePath>(): CurrentRoute<Route> {
+  const location = useLocation()
+  return {
+    route: bracketRoutePattern(routeState()) as Route | null,
+    pathname: location.pathname,
+    params: (routeState().params ?? {}) as RouteParams<Route>,
+    searchParams: new ReadonlyURLSearchParams(location.search),
+  }
+}
+
+interface HookOptions {
+  __h?: (component: { __P?: Element }, ...rest: unknown[]) => void
+}
+
+export function useLinkStatus() {
+  // The router marks a link pending through its anchor, so find the Link this component renders in.
+  const hookOptions = options as HookOptions
+  const hook = hookOptions.__h
+  let parent: Element | undefined
+  hookOptions.__h = (component, ...rest) => {
+    parent = component.__P
+    hook?.(component, ...rest)
+  }
+  const [pending, setPending] = useState(false)
+  hookOptions.__h = hook
+  useEffect(() => {
+    const link = parent?.closest<HTMLAnchorElement & { __pnextHints?: Set<typeof setPending> }>(
+      'a[data-pnext-link]',
+    )
+    if (!link) return
+    const hints = (link.__pnextHints ??= new Set())
+    hints.add(setPending)
+    return () => hints.delete(setPending)
+  }, [])
+  return { pending }
+}
+
+function useLocation() {
+  // Read the URL live each render so any render pairs the address bar with its params;
+  // state is only the re-render trigger (unchanged-URL broadcasts bail out).
+  const location = currentLocation()
+  const [, setLocationKey] = useState(() => locationSignature(location))
+
+  useEffect(() => {
+    patchHistory()
+    const listener = () =>
+      setLocationKey(previous => {
+        const next = locationSignature(currentLocation())
+        return previous === next ? previous : next
+      })
+    locationListeners().add(listener)
+    // Re-read once the listener is attached: the URL can move between the
+    // render that captured it and this effect (a history traversal landing
+    // while a swapped-in tree mounts), and nothing was listening for that one.
+    // Raw popstate is deliberately NOT a subscription source: on a full
+    // traversal the address bar moves before the cached document commits, so
+    // rendering that URL into the departing island can consume the only route
+    // change before the persistent island is grafted into the committed tree.
+    // The router broadcasts shallow traversals immediately and full traversals
+    // after their DOM commit.
+    listener()
+    return () => locationListeners().delete(listener)
+  }, [])
+
+  return location
+}
+
+function locationSignature(location: { pathname: string; search: string; hash: string }) {
+  return `${location.pathname}${location.search}${location.hash}`
+}
+
+// Server only: a request/context store, anchored on globalThis.
+interface ServerStore {
+  request?: { url: string }
+  params?: Record<string, RouteParamValue>
+  routeMode?: string
+}
+
+function serverStore(key: string) {
+  const storage = (globalThis as Record<symbol, { getStore(): ServerStore | undefined }>)[
+    Symbol.for(key)
+  ]
+  return storage?.getStore()
+}
+
+function currentLocation() {
+  if (!process.browser && typeof window === 'undefined') {
+    const href = serverStore('pnext.requestStorage')?.request?.url
+    const url = href ? new URL(href) : undefined
+    return {
+      pathname: url?.pathname ?? '/',
+      // Like Next: dev and dynamic renders see the query; static and cached HTML must not bake it in.
+      search:
+        // eslint-disable-next-line turbo/no-undeclared-env-vars
+        process.env.NODE_ENV === 'development' ||
+        serverStore('pnext.workUnitStorage')?.routeMode === 'dynamic'
+          ? (url?.search ?? '')
+          : '',
+      hash: '',
+    }
+  }
+  return {
+    pathname: window.location.pathname,
+    search: window.location.search,
+    hash: window.location.hash,
+  }
+}
+
+function routeState() {
+  if (!process.browser && typeof window === 'undefined')
+    return { params: serverStore('pnext.requestStorage')?.params } as RouteState
+  const state = (history.state as Record<string, unknown> | null) ?? {}
+  const routeState = window.__PNEXT_ROUTE__ ?? {}
+  const bfcacheId = typeof state.__pnextBfcacheId === 'string' ? state.__pnextBfcacheId : undefined
+  return bfcacheId ? ({ ...routeState, bfcacheId } as RouteState) : routeState
+}
+
+function navigate(url: string, mode: 'push' | 'replace', scroll = true) {
+  if (blockJavascriptUrl(url)) return
+  const next = new URL(url, window.location.href)
+  if (next.origin !== window.location.origin) {
+    const holder = globalThis as { __pnextMpaNavigation?: number }
+    holder.__pnextMpaNavigation = (holder.__pnextMpaNavigation ?? 0) + 1
+    requestAnimationFrame(() =>
+      requestAnimationFrame(() => {
+        if (mode === 'replace') window.location.replace(next.href)
+        else window.location.assign(next.href)
+      }),
+    )
+    return
+  }
+
+  if (next.pathname !== window.location.pathname || next.search !== window.location.search) {
+    void softNavigate(next.href, { replace: mode === 'replace', scroll })
+    return
+  }
+
+  if (mode === 'replace') window.history.replaceState(history.state, '', next)
+  else window.history.pushState(history.state, '', next)
+  scheduleNavigationScroll(next, { scroll })
+  routerState.settleLink?.()
+}
+
+// Exported so compat's link-status can guarantee raw history.pushState /
+// replaceState calls broadcast a location change (ending a link's pending
+// state) even when no useLocation-based hook has mounted yet.
+export function patchHistory() {
+  if ((!process.browser && typeof window === 'undefined') || window.__PNEXT_HISTORY_PATCHED__)
+    return
+  window.__PNEXT_HISTORY_PATCHED__ = true
+  const pushState = window.history.pushState.bind(window.history)
+  const replaceState = window.history.replaceState.bind(window.history)
+
+  // Broadcast only when the URL actually changes. The router itself calls replaceState with the
+  // CURRENT href for bookkeeping - including at the start of every soft navigation - and emitting for
+  // those would clear a just-clicked link's pending state.
+  //
+  // An app-level pushState/replaceState creates an entry that still shows THIS document (shallow
+  // routing). Carrying pnext's own entry state over marks the new entry as pointing at the rendered
+  // document, so a later traversal is a location broadcast rather than a fetch-and-swap of a URL that
+  // may not even exist on the server. Router-initiated calls already carry the keys.
+  function copyInternalState(data: unknown): unknown {
+    const current = (window.history.state as Record<string, unknown> | null) ?? {}
+    const carried: Record<string, unknown> = {}
+    for (const key of Object.keys(current)) {
+      if (key.startsWith('__pnext')) carried[key] = current[key]
+    }
+    if (Object.keys(carried).length === 0) return data
+    const own = (data as Record<string, unknown> | null) ?? {}
+    if (Object.keys(own).some(key => key.startsWith('__pnext'))) return data
+    return { ...own, ...carried }
+  }
+  window.history.pushState = function patchedPushState(data, unused, url) {
+    const before = window.location.href
+    const result = pushState(copyInternalState(data), unused, url)
+    if (window.location.href !== before) emitLocationChange()
+    return result
+  }
+  window.history.replaceState = function patchedReplaceState(data, unused, url) {
+    const before = window.location.href
+    const result = replaceState(copyInternalState(data), unused, url)
+    if (window.location.href !== before) emitLocationChange()
+    return result
+  }
+}