acrylblends 0.6.3 → 0.7.0

package/lib/utils-Cx61GFMC.js

@@ -0,0 +1,125 @@
+//#region ../../plugins/acryl-router/src/core/client/fetch-result-please.ts
+/**
+* @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Acryl's custom needs.
+*
+* @link https://www.npmjs.com/package/fetch-result-please
+*/
+const nullBodyResponses = /* @__PURE__ */ new Set([
+	101,
+	204,
+	205,
+	304
+]);
+/**
+* Smartly parses and return the consumable result from a fetch `Response`.
+*
+* Throwing a structured error if the response is not `ok`. ({@link DetailedError})
+*/
+async function fetchRP(fetchRes) {
+	const _fetchRes = await fetchRes;
+	if ((_fetchRes.body || _fetchRes._bodyInit) && !nullBodyResponses.has(_fetchRes.status)) _fetchRes._data = await _fetchRes[detectResponseType(_fetchRes)]();
+	if (!_fetchRes.ok) throw new DetailedError(`${_fetchRes.status} ${_fetchRes.statusText}`, {
+		statusCode: _fetchRes?.status,
+		detail: {
+			data: _fetchRes?._data,
+			statusText: _fetchRes?.statusText
+		}
+	});
+	return _fetchRes._data;
+}
+var DetailedError = class extends Error {
+	/**
+	* Additional `message` that will be logged AND returned to client
+	*/
+	detail;
+	/**
+	* Additional `code` that will be logged AND returned to client
+	*/
+	code;
+	/**
+	* Additional value that will be logged AND NOT returned to client
+	*/
+	log;
+	/**
+	* Optionally set the status code to return, in a web server context
+	*/
+	statusCode;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "DetailedError";
+		this.log = options.log;
+		this.detail = options.detail;
+		this.code = options.code;
+		this.statusCode = options.statusCode;
+	}
+};
+const jsonRegex = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(?:;.+)?$/i;
+function detectResponseType(response) {
+	const _contentType = response.headers.get("content-type");
+	if (!_contentType) return "text";
+	const contentType = _contentType.split(";").shift();
+	if (jsonRegex.test(contentType)) return "json";
+	return "text";
+}
+//#endregion
+//#region ../../plugins/acryl-router/src/core/client/utils.ts
+const mergePath = (base, path) => {
+	base = base.replace(/\/+$/, "");
+	base = base + "/";
+	path = path.replace(/^\/+/, "");
+	return base + path;
+};
+const replaceUrlParam = (urlString, params) => {
+	for (const [k, v] of Object.entries(params)) {
+		const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??(?=/|$)");
+		urlString = urlString.replace(reg, () => v ? `/${v}` : "");
+	}
+	return urlString;
+};
+const buildSearchParams = (query) => {
+	const searchParams = new URLSearchParams();
+	for (const [k, v] of Object.entries(query)) {
+		if (v === void 0) continue;
+		if (Array.isArray(v)) for (const v2 of v) {
+			if (v2 === void 0) continue;
+			searchParams.append(k, v2);
+		}
+		else searchParams.set(k, v);
+	}
+	return searchParams;
+};
+const replaceUrlProtocol = (urlString, protocol) => {
+	switch (protocol) {
+		case "ws": return urlString.replace(/^http/, "ws");
+		case "http": return urlString.replace(/^ws/, "http");
+	}
+};
+const removeIndexString = (urlString) => {
+	if (/^https?:\/\/[^\/]+?\/index(?=\?|$)/.test(urlString)) return urlString.replace(/\/index(?=\?|$)/, "/");
+	return urlString.replace(/\/index(?=\?|$)/, "");
+};
+function isObject(item) {
+	return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+	if (!isObject(target) && !isObject(source)) return source;
+	const merged = { ...target };
+	for (const key in source) {
+		const value = source[key];
+		if (isObject(merged[key]) && isObject(value)) merged[key] = deepMerge(merged[key], value);
+		else merged[key] = value;
+	}
+	return merged;
+}
+/**
+* Shortcut to get a consumable response from `hc`'s fetch calls (Response), with types inference.
+*
+* Smartly parse the response data, throwing a structured error if the response is not `ok`. ({@link DetailedError})
+*
+* @example const result = await parseResponse(client.posts.$get())
+*/
+async function parseResponse(fetchRes) {
+	return fetchRP(fetchRes);
+}
+//#endregion
+export { removeIndexString as a, DetailedError as c, parseResponse as i, deepMerge as n, replaceUrlParam as o, mergePath as r, replaceUrlProtocol as s, buildSearchParams as t };

package/lib/validator.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, W as ParsedFormValue, X as TypedResponse, Z as ValidationTargets, _ as Env, t as Context, w as FormValue } from "./context-DVQBjuns.js";
+import { G as ParsedFormValue, L as MiddlewareHandler, Q as ValidationTargets, T as FormValue, Z as TypedResponse, t as Context, v as Env } from "./context-DS3fYyG-.js";
 import { D as UnionToIntersection } from "./types-Lqx5BxQF.js";
 
 //#region ../../plugins/acryl-router/src/core/validator/utils.d.ts

package/lib/ws.d.ts

@@ -1,2 +1,2 @@
-import { a as WSEvents, c as WebSocketHelperDefineContext, d as defineWebSocketHelper, i as WSContextInit, l as WebSocketHelperDefineHandler, n as UpgradeWebSocket, o as WSMessageReceive, r as WSContext, s as WSReadyState, t as SendOptions, u as createWSMessageEvent } from "./index-CsvB-F9j.js";
+import { a as WSEvents, c as WebSocketHelperDefineContext, d as defineWebSocketHelper, i as WSContextInit, l as WebSocketHelperDefineHandler, n as UpgradeWebSocket, o as WSMessageReceive, r as WSContext, s as WSReadyState, t as SendOptions, u as createWSMessageEvent } from "./index-BvFh1Gfx.js";
 export { SendOptions, UpgradeWebSocket, WSContext, WSContextInit, WSEvents, WSMessageReceive, WSReadyState, WebSocketHelperDefineContext, WebSocketHelperDefineHandler, createWSMessageEvent, defineWebSocketHelper };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acrylblends",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "The Acryl web framework (import { Acryl } from \"acrylblends\") and the acrylblends command that scaffolds Cordis apps.",
   "license": "MIT",
   "type": "module",
@@ -82,6 +82,10 @@
       "types": "./lib/ip-restriction.d.ts",
       "default": "./lib/ip-restriction.js"
     },
+    "./jsx-renderer": {
+      "types": "./lib/jsx-renderer.d.ts",
+      "default": "./lib/jsx-renderer.js"
+    },
     "./jwk": {
       "types": "./lib/jwk.d.ts",
       "default": "./lib/jwk.js"
@@ -174,6 +178,10 @@
       "types": "./lib/route.d.ts",
       "default": "./lib/route.js"
     },
+    "./ssg": {
+      "types": "./lib/ssg.d.ts",
+      "default": "./lib/ssg.js"
+    },
     "./streaming": {
       "types": "./lib/streaming.d.ts",
       "default": "./lib/streaming.js"
@@ -374,6 +382,10 @@
       "types": "./lib/node-server/conninfo.d.ts",
       "default": "./lib/node-server/conninfo.js"
     },
+    "./node-server/register": {
+      "types": "./lib/node-server/register.d.ts",
+      "default": "./lib/node-server/register.js"
+    },
     "./package.json": "./package.json",
     "./cli": {
       "types": "./dist/index.d.ts",

package/plugins/acryl-inspect/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-inspect",
-    "commit": "60491f81b7346d1f3867fa01ee4e2caffc7baf47"
+    "commit": "7bba3ed0420d87e61d8256fa60614d22af734c8f"
   },
   "vendored": [
     "src",

package/plugins/acryl-node-server/src/register.ts

@@ -0,0 +1,86 @@
+/**
+ * JSX files on Node: `node --import acrylblends/node-server/register src/index.ts`. Node strips TypeScript's types but does not compile JSX, so a
+ * `.tsx` (or `.jsx`) module does not load on its own. This module registers a load hook that compiles exactly those files with the app's own
+ * `typescript` (react-jsx, the `jsxImportSource` of the app's nearest tsconfig.json, `acrylblends/jsx` without one) and leaves every other
+ * module to Node untouched. The output carries an inline source map and source maps are switched on, so a stack trace names the `.tsx` line.
+ *
+ * `typescript` is loaded from the app, on the first JSX file only; the framework itself has no dependencies.
+ */
+
+import { createRequire, registerHooks } from 'node:module'
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/** The JSX runtime the docs set up; an app's tsconfig.json (or a file's own `@jsxImportSource` pragma) chooses another. */
+const DEFAULT_IMPORT_SOURCE = 'acrylblends/jsx'
+const JSX_FILE = /\.[jt]sx$/u
+
+/** The part of the TypeScript compiler API the hook uses. */
+interface Compiler {
+  transpileModule(input: string, options: { fileName: string, compilerOptions: Record<string, unknown> }): { outputText: string }
+  findConfigFile(searchPath: string, fileExists: (path: string) => boolean): string | undefined
+  readConfigFile(path: string, readFile: (path: string) => string | undefined): { config?: unknown }
+  parseJsonConfigFileContent(json: unknown, host: unknown, basePath: string): { options: { jsxImportSource?: string } }
+  sys: { fileExists(path: string): boolean, readFile(path: string): string | undefined }
+}
+
+const compilers = new Map<string, Compiler>()
+const importSources = new Map<string, string>()
+
+/** The app's own `typescript`, resolved from the JSX file, so each app compiles with the version it pinned. */
+function compilerFor(file: string): Compiler {
+  let path: string
+  try {
+    path = createRequire(file).resolve('typescript')
+  } catch {
+    throw new Error(`acrylblends: ${file} contains JSX, and compiling it needs the typescript package in this app: npm install --save-dev typescript`)
+  }
+  let compiler = compilers.get(path)
+  if (compiler === undefined) {
+    compiler = createRequire(path)(path) as Compiler
+    compilers.set(path, compiler)
+  }
+  return compiler
+}
+
+/** `jsxImportSource` of the tsconfig.json nearest to the file (following `extends`), read once per config. */
+function importSourceFor(file: string, ts: Compiler): string {
+  const config = ts.findConfigFile(dirname(file), path => existsSync(path))
+  if (config === undefined) return DEFAULT_IMPORT_SOURCE
+  let source = importSources.get(config)
+  if (source === undefined) {
+    const { config: json } = ts.readConfigFile(config, path => ts.sys.readFile(path))
+    source = ts.parseJsonConfigFileContent(json ?? {}, ts.sys, dirname(config)).options.jsxImportSource ?? DEFAULT_IMPORT_SOURCE
+    importSources.set(config, source)
+  }
+  return source
+}
+
+/** A JSX module compiled to JavaScript, with its source map inline. */
+function compileJsx(file: string, text: string): string {
+  const ts = compilerFor(file)
+  return ts.transpileModule(text, {
+    fileName: file,
+    compilerOptions: {
+      module: 'esnext',
+      target: 'es2022',
+      jsx: 'react-jsx',
+      jsxImportSource: importSourceFor(file, ts),
+      allowImportingTsExtensions: true,
+      inlineSourceMap: true,
+      inlineSources: true,
+    },
+  }).outputText
+}
+
+process.setSourceMapsEnabled(true)
+
+registerHooks({
+  load(url, context, nextLoad) {
+    // Every other module goes straight to Node: the hook's whole cost for them is this test.
+    if (!url.startsWith('file:') || !JSX_FILE.test(new URL(url).pathname)) return nextLoad(url, context)
+    const file = fileURLToPath(url)
+    return { format: 'module', source: compileJsx(file, readFileSync(file, 'utf8')), shortCircuit: true }
+  },
+})

package/plugins/acryl-node-server/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-node-server",
-    "commit": "60491f81b7346d1f3867fa01ee4e2caffc7baf47"
+    "commit": "7bba3ed0420d87e61d8256fa60614d22af734c8f"
   },
   "vendored": [
     "src",
@@ -10,8 +10,10 @@
     "LICENSE"
   ],
   "rewrittenSpecifiers": 28,
-  "digest": "sha256:2adaa64028c1f2a40ed94c0eacf64d32c8c3b8171b52338cb02bfae2fd56ab7c",
-  "testsNotRun": {},
+  "digest": "sha256:9dc4cca51f5a3d8416750c0392135128a0787947f473cff2e00bdb12fe5a63e1",
+  "testsNotRun": {
+    "tests/register.spec.ts": "links typescript from the plugin's own node_modules (ACRYL's workspace layout); the hook is exercised here by the templates' own .tsx tests and verify:scaffolder"
+  },
   "notice": [
     "LICENSE"
   ]

package/plugins/acryl-router/src/core/helper/ssg/index.ts

@@ -0,0 +1,14 @@
+/**
+ * @module
+ * SSG Helper for Acryl.
+ */
+
+export * from './ssg.ts'
+export {
+  X_ACRYL_DISABLE_SSG_HEADER_KEY,
+  ssgParams,
+  isSSGContext,
+  disableSSG,
+  onlySSG,
+} from './middleware.ts'
+export { defaultPlugin, redirectPlugin } from './plugins.ts'

package/plugins/acryl-router/src/core/helper/ssg/middleware.ts

@@ -0,0 +1,83 @@
+import type { Context } from '../../context.ts'
+import type { Env, MiddlewareHandler } from '../../types.ts'
+import { isDynamicRoute } from './utils.ts'
+
+export const SSG_CONTEXT = 'ACRYL_SSG_CONTEXT'
+export const X_ACRYL_DISABLE_SSG_HEADER_KEY = 'x-acryl-disable-ssg'
+
+/**
+ * @deprecated
+ * Use `X_ACRYL_DISABLE_SSG_HEADER_KEY` instead.
+ * This constant will be removed in the next minor version.
+ */
+export const SSG_DISABLED_RESPONSE = (() => {
+  try {
+    return new Response('SSG is disabled', {
+      status: 404,
+      headers: { [X_ACRYL_DISABLE_SSG_HEADER_KEY]: 'true' },
+    })
+  } catch {
+    return null
+  }
+})() as Response
+
+interface SSGParam {
+  [key: string]: string
+}
+export type SSGParams = SSGParam[]
+
+interface SSGParamsMiddleware {
+  <E extends Env = Env>(
+    generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>
+  ): MiddlewareHandler<E>
+  <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>
+}
+
+export type AddedSSGDataRequest = Request & {
+  ssgParams?: SSGParams
+}
+
+/**
+ * Define SSG Route
+ */
+export const ssgParams: SSGParamsMiddleware = (params) => async (c, next) => {
+  if (isDynamicRoute(c.req.path)) {
+    ;(c.req.raw as AddedSSGDataRequest).ssgParams = Array.isArray(params) ? params : await params(c)
+    return c.notFound() // Prevent subsequent handler execution after ssgParams
+  }
+  await next()
+}
+
+/**
+ * @experimental
+ * `isSSGContext` is an experimental feature.
+ * The API might be changed.
+ */
+export const isSSGContext = (c: Context): boolean => !!c.env?.[SSG_CONTEXT]
+
+/**
+ * @experimental
+ * `disableSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export const disableSSG = (): MiddlewareHandler =>
+  async function disableSSG(c, next) {
+    if (isSSGContext(c)) {
+      c.header(X_ACRYL_DISABLE_SSG_HEADER_KEY, 'true')
+      return c.notFound()
+    }
+    await next()
+  }
+
+/**
+ * @experimental
+ * `onlySSG` is an experimental feature.
+ * The API might be changed.
+ */
+export const onlySSG = (): MiddlewareHandler =>
+  async function onlySSG(c, next) {
+    if (!isSSGContext(c)) {
+      return c.notFound()
+    }
+    await next()
+  }

package/plugins/acryl-router/src/core/helper/ssg/plugins.ts

@@ -0,0 +1,72 @@
+import { html } from '../html/index.ts'
+import type { SSGPlugin } from './ssg.ts'
+
+/**
+ * The default plugin that defines the recommended behavior.
+ *
+ * @experimental
+ * `defaultPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+export const defaultPlugin = (): SSGPlugin => {
+  return {
+    afterResponseHook: (res) => {
+      if (res.status !== 200) {
+        return false
+      }
+      return res
+    },
+  }
+}
+
+const REDIRECT_STATUS_CODES = new Set([301, 302, 303, 307, 308])
+
+const generateRedirectHtml = (location: string) => {
+  // prettier-ignore
+  const content = html`<!DOCTYPE html>
+<title>Redirecting to: ${location}</title>
+<meta http-equiv="refresh" content="0;url=${location}" />
+<meta name="robots" content="noindex" />
+<link rel="canonical" href="${location}" />
+<body>
+<a href="${location}">Redirecting to <code>${location}</code></a>
+</body>
+`
+  return content.toString().replace(/\n/g, '')
+}
+
+/**
+ * The redirect plugin that generates HTML redirect pages for HTTP redirect responses for status codes 301, 302, 303, 307 and 308.
+ *
+ * When used with `defaultPlugin`, place `redirectPlugin` before it, because `defaultPlugin` skips non-200 responses.
+ *
+ * ```ts
+ * // ✅ Will work as expected
+ * toSSG(app, fs, { plugins: [redirectPlugin(), defaultPlugin()] })
+ *
+ * // ❌ Will not work as expected
+ * toSSG(app, fs, { plugins: [defaultPlugin(), redirectPlugin()] })
+ * ```
+ *
+ * @experimental
+ * `redirectPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+export const redirectPlugin = (): SSGPlugin => {
+  return {
+    afterResponseHook: (res) => {
+      if (REDIRECT_STATUS_CODES.has(res.status)) {
+        const location = res.headers.get('Location')
+        if (!location) {
+          return false
+        }
+        const htmlBody = generateRedirectHtml(location)
+        return new Response(htmlBody, {
+          status: 200,
+          headers: { 'Content-Type': 'text/html; charset=utf-8' },
+        })
+      }
+      return res
+    },
+  }
+}