@absolutejs/absolute 0.20.0-beta.181 → 0.20.0-beta.183

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

@@ -0,0 +1,23 @@
+/** True when `routes` (a page's runtime `Routes` array) can match `path`,
+ *  the request path with the base href removed. Conservative: unsure
+ *  cases match. */
+export declare const matchesAngularColocatedRoutes: (routes: unknown, path: string) => boolean;
+/** The request path below `baseHref` (which ends in `/`), or `null` when the
+ *  path isn't under it. Repeated slashes collapse first, as they do in the
+ *  URL the page renders for. */
+export declare const pathBelowBaseHref: (pathname: string, baseHref: string) => string | null;
+type ColocatedRouteRequest = {
+    handlerProviders: unknown;
+    pageModule: Record<string, unknown>;
+    request: Request | undefined;
+    /** The Elysia route pattern that matched this request. */
+    route: string | undefined;
+    /** The base href derived from `route` for this request. */
+    runtimeBaseHref: string | null;
+};
+/** True only when the page's colocated routes certainly can't match this
+ *  request: the page exports `routes` and the build wired them into its
+ *  `providers`, the Elysia route is a wildcard mount whose base is known
+ *  for this request, and no route matches the path below it. */
+export declare const isUnmatchedColocatedRoute: ({ handlerProviders, pageModule, request, route, runtimeBaseHref }: ColocatedRouteRequest) => boolean;
+export {};

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/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

@@ -28,5 +28,6 @@ export declare const svelteCheckIncludes: (projectRoot: string, configuredDirs:
 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 dedupeSvelteResult: (results: CheckerResult[], read?: (file: string) => string | null) => CheckerResult[];
 export declare const typecheck: (configPath?: string) => Promise<void>;
 export {};

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

@@ -15,3 +15,44 @@ export declare const withoutReported: (output: string, reported: ReadonlySet<str
     output: string;
     remaining: number;
 };
+type SveltePosition = {
+    character: number;
+    line: number;
+};
+export type SvelteCheckDiagnostic = {
+    code?: number | string;
+    end: SveltePosition;
+    filename: string;
+    message: string;
+    source?: string;
+    start: SveltePosition;
+    type: 'ERROR' | 'WARNING';
+};
+/** svelte-check's machine-verbose output: its errors, its failures, and any
+ *  other line it (or node) printed, kept verbatim. Warnings are dropped:
+ *  `--threshold error` keeps them out of the output, and this keeps them
+ *  out of the count if one ever gets through. */
+export declare const parseSvelteCheckOutput: (output: string) => {
+    diagnostics: SvelteCheckDiagnostic[];
+    failures: string[];
+    other: string[];
+};
+/** The `file:line:column:code` key of a TypeScript diagnostic, 1-based like
+ *  the plain checker's; null for the Svelte compiler's own diagnostics,
+ *  which no other checker reports. */
+export declare const svelteDiagnosticKey: (diagnostic: SvelteCheckDiagnostic, cwd?: string) => string | null;
+/** svelte-check's errors in tsc's pretty shape: `file:line:col - error
+ *  TS2322: message`, then the line with the span underlined. */
+export declare const formatSvelteDiagnostics: (diagnostics: readonly SvelteCheckDiagnostic[], readSource: (file: string) => string | null, cwd?: string) => string;
+/**
+ * svelte-check's output, read and rendered for people, without the errors
+ * the plain checker already reported (`reported`, from diagnosticKeys).
+ * A failure or any unrecognised line is kept, and keeps the run failing.
+ * `remaining` is 0 when everything svelte-check found is already on screen.
+ */
+export declare const svelteCheckReport: (output: string, reported: ReadonlySet<string>, readSource: (file: string) => string | null, cwd?: string) => {
+    dropped: number;
+    output: string;
+    remaining: number;
+};
+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/hot/analyze.d.ts

@@ -1,5 +1,5 @@
 import type * as TS from 'typescript';
-export declare const ANALYZER_VERSION = 2;
+export declare const ANALYZER_VERSION = 3;
 export type ExportKind = 'class' | 'function' | 'live' | 'value';
 export type ImportUse = {
     /** Resolved module path the binding comes from. */

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

@@ -9,3 +9,4 @@ 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>;
+export declare const renderSpaNotFoundResponse: (request: Request | undefined) => Promise<Response>;