@absolutejs/absolute 0.20.0-beta.180 → 0.20.0-beta.182

package/dist/src/angular/components/constants.d.ts

@@ -30,6 +30,7 @@ export declare const CONFIG_DEFAULT_PORT = 4099;
 export declare const HMR_UPDATE_TIMEOUT_MS = 2000;
 export declare const HOOK_SIGNATURE_LENGTH = 12;
 export declare const EXCLUDE_LAST_OFFSET = -1;
+export declare const HTML_CONTENT_TYPE = "text/html; charset=utf-8";
 export declare const HTTP_STATUS_OK = 200;
 export declare const HTTP_STATUS_BAD_REQUEST = 400;
 export declare const HTTP_STATUS_NOT_FOUND = 404;

package/dist/src/angular/components/defer-slot-payload.d.ts

@@ -1,5 +1,10 @@
 export type AngularDeferSlotPayload = {
     data?: Record<string, string>;
+    /** Size-accounting only: the streaming pipeline measures it for
+     *  `maxSlotHtmlSizeBytes` and slot metrics. Never insert it into the DOM;
+     *  the slot renders from `data` through Angular's own escaping, and the
+     *  stream-swap runtime deliberately skips `angular-defer` payloads.
+     *  Interpolated values in it are HTML-escaped at build time. */
     html: string;
     kind: 'angular-defer';
     state?: 'error' | 'resolved';

package/dist/src/angular/staticAnalyzeSpaRoutes.d.ts

@@ -4,6 +4,15 @@ export declare const analyzeAngularSpaRouteFile: (filePath: string) => Promise<{
     routes: SpaRoute[];
     sourceFile: string;
 } | null>;
+/** Read a page's colocated `export const routes = [...]` — the routes the
+ *  build wires into `provideRouter` itself (see scanAngularPageRoutes).
+ *  Their mount path comes from the Elysia route at request time, so the
+ *  host's `baseHref` is `/` and the paths stay relative; dev uses these
+ *  only to report route edits, never for the 404 table. */
+export declare const analyzeAngularColocatedRouteFile: (filePath: string) => Promise<SpaHost | null>;
+/** Every colocated-routes page under `angularDirectory` that is not
+ *  already an `APP_BASE_HREF` + `provideRouter` host. */
+export declare const analyzeAngularColocatedRoutes: (angularDirectory: string) => Promise<SpaHost[]>;
 /** Statically scan an Angular page-source directory for SPA hosts —
  *  files that both import `APP_BASE_HREF`/`provideRouter` and declare
  *  an `APP_BASE_HREF` provider plus a literal `Routes` array. Returns

package/dist/src/cli/scripts/manifestKeysEditorHint.d.ts

@@ -0,0 +1,9 @@
+type TsconfigLists = {
+    exclude?: unknown;
+    files?: unknown;
+    include?: unknown;
+};
+/** The note, or null when tsconfig.json (its `include`, `files` and
+ *  `exclude`) already lists the declaration. */
+export declare const manifestKeysEditorHint: (config: TsconfigLists) => string | null;
+export {};

package/dist/src/cli/scripts/typecheck.d.ts

@@ -16,10 +16,17 @@ export declare const svelteShimSource: (fileNames: readonly string[]) => string;
  *  folder inside another one folded into it so no two mirrors overlap.
  *  Relative to the project root. */
 export declare const svelteRoots: (projectRoot: string, svelteDirs: readonly string[], svelteFiles: readonly string[]) => string[];
+/** What svelte-check's program includes for each Svelte root: a configured
+ *  svelteDirectory whole, as it always was, and only the `.svelte` files of
+ *  a root outside one (an island folder), whose `.ts` files (the registry)
+ *  belong to the plain checker and would otherwise be reported twice.
+ *  Relative to the generated config in the cache directory. */
+export declare const svelteCheckIncludes: (projectRoot: string, configuredDirs: readonly string[], roots: readonly string[]) => string[];
 /** Every service's server entry, deduplicated, keeping only the ones that are
  *  actually on disk — `absolute typecheck` also runs in plain TypeScript
  *  libraries, which have no server entry at all. */
 export declare const serverEntryPaths: (targets: readonly AbsoluteServiceConfig[]) => string[];
+export declare const dedupeAngularResult: (results: CheckerResult[], cacheDir: string) => CheckerResult[];
 export declare const dedupeVueResult: (results: CheckerResult[]) => CheckerResult[];
 export declare const typecheck: (configPath?: string) => Promise<void>;
 export {};

package/dist/src/constants.d.ts

@@ -30,6 +30,7 @@ export declare const CONFIG_DEFAULT_PORT = 4099;
 export declare const HMR_UPDATE_TIMEOUT_MS = 2000;
 export declare const HOOK_SIGNATURE_LENGTH = 12;
 export declare const EXCLUDE_LAST_OFFSET = -1;
+export declare const HTML_CONTENT_TYPE = "text/html; charset=utf-8";
 export declare const HTTP_STATUS_OK = 200;
 export declare const HTTP_STATUS_BAD_REQUEST = 400;
 export declare const HTTP_STATUS_NOT_FOUND = 404;

package/dist/src/core/prerender.d.ts

@@ -1,9 +1,16 @@
 import type { StaticConfig } from '../../types/build';
+export type PrerenderFailure = {
+    /** Why the route couldn't be pre-rendered */
+    reason: string;
+    route: string;
+};
 export type PrerenderResult = {
     /** Map of route path → rendered HTML file path on disk */
     routes: Map<string, string>;
     /** Directory where pre-rendered files are stored */
     dir: string;
+    /** Routes that couldn't be pre-rendered; they render per request */
+    failures: PrerenderFailure[];
 };
 type LogFn = (message: string) => void;
 /** Header used to bypass the prerender cache during ISR re-renders */
@@ -17,6 +24,9 @@ export declare const readTimestamp: (htmlPath: string) => number;
  * with the bypass header so it hits SSR instead of the cache.
  */
 export declare const rerenderRoute: (route: string, port: number, prerenderDir: string) => Promise<boolean>;
+/** The line `absolute start` and `absolute compile` print, once, for a
+ *  route that couldn't be pre-rendered. */
+export declare const formatPrerenderFailure: ({ reason, route }: PrerenderFailure) => string;
 /**
  * Pre-render routes by fetching them from a running server and saving the HTML to disk.
  *

package/dist/src/dev/spaRouteRefresh.d.ts

@@ -1,13 +1,20 @@
 import type { ResolvedBuildPaths } from './configResolver';
-type SpaFramework = 'angular' | 'react' | 'svelte' | 'vue';
-type SpaRouteChange = {
+export type SpaFramework = 'angular' | 'react' | 'svelte' | 'vue';
+export type SpaRouteChange = {
     added: string[];
     file: string;
     framework: SpaFramework;
     removed: string[];
 };
+/** Re-analyze `files` without touching the route table. `changes` lists
+ *  each file whose routes differ from the table; `publish(frameworks?)`
+ *  writes those changes (all of them, or only the given frameworks') into
+ *  the table and logs them. Publishing a framework twice is a no-op. */
+export declare const readSpaRouteChanges: (files: string[], paths: ResolvedBuildPaths) => Promise<{
+    changes: SpaRouteChange[];
+    publish: (frameworks?: SpaFramework[]) => Promise<void>;
+}>;
 /** Re-analyze `files` and patch the in-memory SPA route table (plus the
- *  build's `spa-routes.json`). Returns one entry per file whose routes
- *  changed; each is logged as a `routes update` line. */
+ *  build's `spa-routes.json`) at once. Returns one entry per file whose
+ *  routes changed; each is logged as a `routes update` line. */
 export declare const refreshSpaRoutesForFiles: (files: string[], paths: ResolvedBuildPaths) => Promise<SpaRouteChange[]>;
-export {};

package/dist/src/react/browser.d.ts

@@ -1,3 +1,4 @@
 export { Island } from './Island.browser';
 export { createTypedIsland } from './createIsland.browser';
 export { useIslandStore } from './hooks/useIslandStore';
+export { getCspNonce } from '../utils/pageCspNonce';

package/dist/src/react/index.d.ts

@@ -4,3 +4,4 @@ export { handleReactServerPageRequest } from './serverComponents/pageHandler';
 export { Island } from './Island';
 export { createTypedIsland } from './createIsland';
 export { useIslandStore } from './hooks/useIslandStore';
+export { getCspNonce } from '../utils/pageCspNonce';

package/dist/src/svelte/lowerAwaitSlotSyntax.d.ts

@@ -1,4 +1,27 @@
 export declare const AWAIT_STREAM_DIRECTIVE = "<!-- absolute:stream -->";
+export declare const AWAIT_SCOPE_CLASS_PLACEHOLDER = "__absoluteAwaitScopeClass__";
+export declare const AWAIT_HTML_HELPERS_SOURCE: string;
+/** Puts `scopeClass` (or nothing, for a component without a `<style>`)
+ *  where the lowering left the scoped-CSS class placeholder. */
+export declare const applyAwaitScopeClass: (code: string, scopeClass: string) => string;
+/** A `cssHash` compile option that hashes exactly as Svelte's default does
+ *  (svelte/src/compiler/validate-options.js) and remembers the class, plus
+ *  `apply`, which writes that class into the compiled code of a lowered
+ *  component. Svelte only calls `cssHash` for a component with a `<style>`,
+ *  so without one the placeholder becomes an empty string. One capture per
+ *  `compile` call. */
+export declare const createAwaitScopeClassCapture: () => {
+    apply: (code: string) => string;
+    cssHash: (args: {
+        name: string;
+        filename: string;
+        css: string;
+        hash: (input: string) => string;
+    }) => string;
+};
+/** Turns a branch's markup into a JS template literal that renders it,
+ *  escaping every expression as Svelte's SSR would. */
+export declare const branchMarkupToTemplateLiteral: (markup: string, branch?: string, filePath?: string) => string;
 /** Lowers every `{#await}` marked with `AWAIT_STREAM_DIRECTIVE` to a
  *  streaming slot and leaves every other block to Svelte. Throws for a
  *  marked block it can't stream. */

package/dist/src/utils/pageCspNonce.d.ts

@@ -0,0 +1,14 @@
+/** This page's Content-Security-Policy nonce, for the inline `<script>` and
+ *  `<style>` tags a page component writes itself:
+ *
+ *  ```tsx
+ *  <script nonce={getCspNonce()} dangerouslySetInnerHTML={{ __html: code }} />
+ *  ```
+ *
+ *  Safe in code that also runs in the browser. During SSR it is the
+ *  request's nonce (the one in the policy header); in the browser it is the
+ *  same value, read back from the page's own scripts, so the component
+ *  renders the same nonce on both sides. Undefined without
+ *  `secureHeaders()`. In a route handler, `cspNonce` in the context is the
+ *  same value. */
+export declare const getCspNonce: () => string | undefined;

package/dist/src/utils/spaRouteManifest.d.ts

@@ -5,5 +5,7 @@ export type RuntimeSpaHost = SpaHost & {
 };
 export declare const setSpaRouteManifest: (hosts: RuntimeSpaHost[]) => void;
 export declare const getSpaRouteManifest: () => RuntimeSpaHost[];
+export declare const getObservedSpaRoutes: () => RuntimeSpaHost[];
+export declare const setObservedSpaRoutes: (hosts: RuntimeSpaHost[]) => void;
 export declare const isKnownSpaRoute: (framework: keyof ConventionsMap, pageName: string, request: Request | undefined) => boolean;
 export declare const renderSpaNotFound: (framework: keyof ConventionsMap, pageName: string, request: Request | undefined) => Promise<Response | null>;

package/dist/svelte/components/Image.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import type { ImageProps } from '@absolutejs/absolute/image';
+	import type { ImageProps } from '../../../types/image';
 	import {
 		DEFAULT_QUALITY,
 		buildOptimizedUrl,

package/dist/svelte/components/Island.svelte

@@ -29,7 +29,7 @@
 			.replaceAll('>', '>');
 
 	const buildFallbackMarkup = (runtimeProps: RuntimeIslandRenderProps) => {
-		const attributes = [
+		const attributes: [string, string][] = [
 			['data-component', runtimeProps.component],
 			['data-framework', runtimeProps.framework],
 			['data-hydrate', runtimeProps.hydrate ?? 'load'],