@abs-test/absolutejs-test 0.1.0

package/dist/src/build/buildReactVendor.d.ts

@@ -0,0 +1,8 @@
+/** Compute the deterministic vendor paths mapping (no build needed).
+ *  This can be called before vendor files exist on disk. */
+export declare const computeVendorPaths: () => Record<string, string>;
+/** Build React packages into stable vendor files (no content hash).
+ *  Output goes to {buildDir}/react/vendor/ with predictable names like
+ *  react.js, react-dom_client.js, etc. These files never change between
+ *  rebuilds, so the browser always loads React from a single source. */
+export declare const buildReactVendor: (buildDir: string) => Promise<void>;

package/dist/src/build/compileSvelte.d.ts

@@ -0,0 +1,11 @@
+type Built = {
+    ssr: string;
+    client: string;
+};
+type Cache = Map<string, Built>;
+export declare const compileSvelte: (entryPoints: string[], svelteRoot: string, cache?: Cache, isDev?: boolean) => Promise<{
+    svelteIndexPaths: string[];
+    svelteClientPaths: string[];
+    svelteServerPaths: string[];
+}>;
+export {};

package/dist/src/build/compileVue.d.ts

@@ -0,0 +1,33 @@
+import { type SFCDescriptor } from '@vue/compiler-sfc';
+export type VueChangeType = 'style-only' | 'template-only' | 'script' | 'full';
+export declare const vueHmrMetadata: Map<string, {
+    hmrId: string;
+    changeType: VueChangeType;
+}>;
+/**
+ * Detect what type of change occurred in a Vue component
+ * Returns 'template-only' for template changes (supports rerender)
+ * Returns 'script' for script/scriptSetup changes (requires reload)
+ * Returns 'full' for first compile or when detection fails
+ */
+export declare const detectVueChangeType: (filePath: string, descriptor: SFCDescriptor) => VueChangeType;
+/**
+ * Generate a stable HMR ID for a Vue component
+ * Uses relative path from Vue root without extension
+ * Example: "pages/VueExample" or "components/CountButton"
+ */
+export declare const generateVueHmrId: (sourceFilePath: string, vueRootDir: string) => string;
+/**
+ * Clear HMR caches (useful for testing or full rebuilds)
+ */
+export declare const clearVueHmrCaches: () => void;
+export declare const compileVue: (entryPoints: string[], vueRootDir: string, isDev?: boolean) => Promise<{
+    vueClientPaths: string[];
+    vueCssPaths: string[];
+    vueIndexPaths: string[];
+    vueServerPaths: string[];
+    hmrMetadata: Map<string, {
+        hmrId: string;
+        changeType: VueChangeType;
+    }>;
+}>;

package/dist/src/build/generateManifest.d.ts

@@ -0,0 +1,2 @@
+import { BuildArtifact } from 'bun';
+export declare const generateManifest: (outputs: BuildArtifact[], buildPath: string) => Record<string, string>;

package/dist/src/build/generateReactIndexes.d.ts

@@ -0,0 +1 @@
+export declare const generateReactIndexFiles: (reactPagesDirectory: string, reactIndexesDirectory: string, isDev?: boolean) => Promise<void>;

package/dist/src/build/htmlScriptHMRPlugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bun build plugin that wraps HTML/HTMX scripts with import.meta.hot support
+ * for granular HMR. This allows script changes to hot-reload independently
+ * without triggering a full HTML page rebuild.
+ */
+import type { BunPlugin } from 'bun';
+/**
+ * Creates a Bun build plugin that wraps HTML/HTMX scripts with HMR support
+ * @param htmlDir - The HTML directory path (normalized with forward slashes)
+ * @param htmxDir - The HTMX directory path (normalized with forward slashes)
+ * @returns Bun build plugin
+ */
+export declare const createHTMLScriptHMRPlugin: (htmlDir?: string, htmxDir?: string) => BunPlugin;

package/dist/src/build/outputLogs.d.ts

@@ -0,0 +1 @@
+export declare const outputLogs: (logs: (BuildMessage | ResolveMessage)[]) => void;

package/dist/src/build/rewriteReactImports.d.ts

@@ -0,0 +1,8 @@
+/** Post-process bundled output files to rewrite bare React specifiers
+ *  (e.g. `from "react"`) to stable vendor paths (e.g. `from "/vendor/react.js"`).
+ *
+ *  This runs after Bun.build() when React is marked as external in dev mode.
+ *  Bun preserves bare specifiers for external packages, but browsers can't
+ *  resolve them. Rewriting to absolute URL paths lets the browser load
+ *  the pre-built vendor files directly. */
+export declare const rewriteReactImports: (outputPaths: string[], vendorPaths: Record<string, string>) => Promise<void>;

package/dist/src/build/scanEntryPoints.d.ts

@@ -0,0 +1 @@
+export declare const scanEntryPoints: (dir: string, pattern: string) => Promise<string[]>;

package/dist/src/build/updateAssetPaths.d.ts

@@ -0,0 +1 @@
+export declare const updateAssetPaths: (manifest: Record<string, string>, directory: string) => Promise<void>;

package/dist/src/build/wrapHTMLScript.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Wraps HTML/HTMX TypeScript/JavaScript scripts with import.meta.hot support
+ * for granular HMR updates. This allows script changes to hot-reload
+ * without triggering a full HTML page rebuild.
+ *
+ * The wrapper is minimal - it just adds import.meta.hot.accept() so Bun
+ * knows this module can be hot-reloaded. Event listener cleanup is handled
+ * by the HMR client (cloning elements before script re-execution).
+ */
+/**
+ * Wrap a script with HMR support using Bun's import.meta.hot API
+ * @param code - The original script code
+ * @param scriptId - Unique identifier for this script (usually the file path)
+ * @returns Wrapped code with HMR support
+ */
+export declare const wrapHTMLScriptWithHMR: (code: string, scriptId: string) => string;
+/**
+ * Check if a file path is an HTML/HTMX script that should be wrapped
+ * @param filePath - The file path to check
+ * @param htmlDir - The HTML directory path
+ * @param htmxDir - The HTMX directory path
+ * @returns true if this script should be wrapped with HMR
+ */
+export declare const isHTMLScript: (filePath: string, htmlDir?: string, htmxDir?: string) => boolean;

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/src/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const UNFOUND_INDEX = -1;
+export declare const SECONDS_IN_A_MINUTE = 60;
+export declare const MILLISECONDS_IN_A_SECOND = 1000;
+export declare const MILLISECONDS_IN_A_MINUTE: number;
+export declare const MINUTES_IN_AN_HOUR = 60;
+export declare const HOURS_IN_DAY = 24;
+export declare const MILLISECONDS_IN_A_DAY: number;
+export declare const TIME_PRECISION = 2;
+export declare const TWO_THIRDS: number;
+export declare const DEFAULT_PORT = 3000;
+export declare const DEFAULT_CHUNK_SIZE = 16384;
+export declare const BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet";

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

@@ -0,0 +1,2 @@
+import type { BuildConfig } from '../../types/build';
+export declare const build: ({ buildDirectory, assetsDirectory, publicDirectory, reactDirectory, htmlDirectory, htmxDirectory, angularDirectory, svelteDirectory, vueDirectory, tailwind, options, incrementalFiles }: BuildConfig) => Promise<Record<string, string>>;

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

@@ -0,0 +1,6 @@
+import type { BuildConfig } from '../../types/build';
+import { type HMRState } from '../dev/clientManager';
+export declare const devBuild: (config: BuildConfig) => Promise<{
+    hmrState: HMRState;
+    manifest: Record<string, string>;
+}>;

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

@@ -0,0 +1,7 @@
+/** Module-level dev vendor paths state.
+ *  Set by devBuild() before the initial build so that build() can
+ *  externalize React and rewrite imports to stable vendor files.
+ *  Production builds never call setDevVendorPaths, so the getter
+ *  returns null and build() bundles React normally. */
+export declare const setDevVendorPaths: (paths: Record<string, string>) => void;
+export declare const getDevVendorPaths: () => Record<string, string> | null;

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

@@ -0,0 +1,4 @@
+export * from './build';
+export * from './devBuild';
+export * from './lookup';
+export * from './pageHandlers';

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

@@ -0,0 +1,3 @@
+export declare const asset: (source: Record<string, string> | {
+    manifest: Record<string, string>;
+}, name: string) => string;

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

@@ -0,0 +1,15 @@
+import { ComponentType as ReactComponent } from 'react';
+import { Component as SvelteComponent } from 'svelte';
+import { Component as VueComponent } from 'vue';
+import { PropsArgs } from '../../types/build';
+export declare const handleReactPageRequest: <Props extends Record<string, unknown> = Record<never, never>>(PageComponent: ReactComponent<Props>, index: string, ...props: keyof Props extends never ? [] : [props: Props]) => Promise<Response>;
+type HandleSveltePageRequest = {
+    (PageComponent: SvelteComponent<Record<string, never>>, pagePath: string, indexPath: string): Promise<Response>;
+    <P extends Record<string, unknown>>(PageComponent: SvelteComponent<P>, pagePath: string, indexPath: string, props: P): Promise<Response>;
+};
+export declare const handleSveltePageRequest: HandleSveltePageRequest;
+export declare const handleVuePageRequest: <Props extends Record<string, unknown> = Record<never, never>>(_PageComponent: VueComponent<Props>, pagePath: string, indexPath: string, headTag?: `<head>${string}</head>`, ...props: keyof Props extends never ? [] : [props: Props]) => Promise<Response>;
+export declare const handleHTMLPageRequest: (pagePath: string) => Bun.BunFile;
+export declare const handleHTMXPageRequest: (pagePath: string) => Bun.BunFile;
+export declare const handlePageRequest: <Component>(PageComponent: Component, ...props: PropsArgs<Component>) => void;
+export {};

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

@@ -0,0 +1,12 @@
+/** Determine Content-Type from a file path extension */
+export declare const getMimeType: (filePath: string) => string;
+/** Upsert build outputs into the in-memory asset store.
+ *  Evicts previous entries for the same logical asset (same base name,
+ *  different hash) so stale paths don't accumulate. */
+export declare const populateAssetStore: (store: Map<string, Uint8Array>, manifest: Record<string, string>, buildDir: string) => Promise<void>;
+/** Remove hashed build files whose logical identity has a newer version.
+ *  Checks both client assets (from the store) and SSR server files (from
+ *  the manifest's absolute-path entries). Non-blocking async version. */
+export declare const cleanStaleAssets: (store: Map<string, Uint8Array>, manifest: Record<string, string>, buildDir: string) => Promise<void>;
+/** Look up an asset by its web path. Returns bytes or undefined. */
+export declare const lookupAsset: (store: Map<string, Uint8Array>, path: string) => Uint8Array | undefined;

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

@@ -0,0 +1 @@
+export declare const buildHMRClient: () => Promise<string>;

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

@@ -0,0 +1,26 @@
+import type { FSWatcher } from 'fs';
+import { type DependencyGraph } from './dependencyGraph';
+import { type ModuleVersions } from './moduleVersionTracker';
+import type { HMRWebSocket } from '../../types/websocket';
+import type { BuildConfig } from '../../types/build';
+import { type ResolvedBuildPaths } from './configResolver';
+export type HMRState = {
+    connectedClients: Set<HMRWebSocket>;
+    dependencyGraph: DependencyGraph;
+    isRebuilding: boolean;
+    rebuildQueue: Set<string>;
+    rebuildTimeout: NodeJS.Timeout | null;
+    fileChangeQueue: Map<string, string[]>;
+    debounceTimeout: NodeJS.Timeout | null;
+    fileHashes: Map<string, string>;
+    watchers: FSWatcher[];
+    moduleVersions: ModuleVersions;
+    sourceFileVersions: Map<string, number>;
+    config: BuildConfig;
+    resolvedPaths: ResolvedBuildPaths;
+    vueChangeTypes: Map<string, 'template-only' | 'script' | 'full'>;
+    assetStore: Map<string, Uint8Array>;
+};
+export declare const createHMRState: (config: BuildConfig) => HMRState;
+export declare const incrementSourceFileVersion: (state: HMRState, filePath: string) => number;
+export declare const incrementSourceFileVersions: (state: HMRState, filePaths: string[]) => void;

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

@@ -0,0 +1,13 @@
+import type { BuildConfig } from '../../types/build';
+/** Normalize and default build paths so HMR works outside the example app. */
+export declare const resolveBuildPaths: (config: BuildConfig) => {
+    buildDir: string;
+    assetsDir: string | undefined;
+    reactDir: string | undefined;
+    svelteDir: string | undefined;
+    vueDir: string | undefined;
+    angularDir: string | undefined;
+    htmlDir: string | undefined;
+    htmxDir: string | undefined;
+};
+export type ResolvedBuildPaths = ReturnType<typeof resolveBuildPaths>;

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

@@ -0,0 +1,13 @@
+export type DependencyGraph = {
+    dependents: Map<string, Set<string>>;
+    dependencies: Map<string, Set<string>>;
+};
+export declare const createDependencyGraph: () => {
+    dependencies: Map<any, any>;
+    dependents: Map<any, any>;
+};
+export declare const extractDependencies: (filePath: string) => string[];
+export declare const addFileToGraph: (graph: DependencyGraph, filePath: string) => void;
+export declare const getAffectedFiles: (graph: DependencyGraph, changedFile: string) => string[];
+export declare const removeFileFromGraph: (graph: DependencyGraph, filePath: string) => void;
+export declare const buildInitialDependencyGraph: (graph: DependencyGraph, directories: string[]) => void;

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

@@ -0,0 +1,2 @@
+export declare const computeFileHash: (filePath: string) => string;
+export declare const hasFileChanged: (filePath: string, currentHash: string, previousHashes: Map<string, string>) => boolean;

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

@@ -0,0 +1,3 @@
+import type { BuildConfig } from '../../types/build';
+import type { HMRState } from './clientManager';
+export declare const startFileWatching: (state: HMRState, config: BuildConfig, onFileChange: (filePath: string) => void) => void;

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

@@ -0,0 +1,21 @@
+import { type ComponentType } from './reactComponentClassifier';
+export type ModuleUpdate = {
+    sourceFile: string;
+    framework: string;
+    moduleKeys: string[];
+    modulePaths: Record<string, string>;
+    componentType?: ComponentType;
+};
+export declare const mapSourceFileToManifestKeys: (sourceFile: string, framework: string, resolvedPaths?: {
+    reactDir?: string;
+    svelteDir?: string;
+    vueDir?: string;
+    angularDir?: string;
+}) => string[];
+export declare const createModuleUpdates: (changedFiles: string[], framework: string, manifest: Record<string, string>, resolvedPaths?: {
+    reactDir?: string;
+    svelteDir?: string;
+    vueDir?: string;
+    angularDir?: string;
+}) => ModuleUpdate[];
+export declare const groupModuleUpdatesByFramework: (updates: ModuleUpdate[]) => Map<string, ModuleUpdate[]>;

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

@@ -0,0 +1,7 @@
+export type ModuleVersion = number;
+export type ModuleVersions = Map<string, ModuleVersion>;
+export declare const getNextVersion: () => number;
+export declare const createModuleVersionTracker: () => Map<string, number>;
+export declare const incrementModuleVersion: (versions: ModuleVersions, modulePath: string) => number;
+export declare const incrementModuleVersions: (versions: ModuleVersions, modulePaths: string[]) => Map<string, number>;
+export declare const serializeModuleVersions: (versions: ModuleVersions) => Record<string, number>;

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

@@ -0,0 +1,5 @@
+import { BuildConfig } from '../../types/build';
+import type { ResolvedBuildPaths } from './configResolver';
+export declare const getWatchPaths: (config: BuildConfig, resolved?: ResolvedBuildPaths) => string[];
+export declare const shouldIgnorePath: (path: string) => boolean;
+export declare const detectFramework: (filePath: string, resolved?: ResolvedBuildPaths) => "react" | "vue" | "svelte" | "html" | "assets" | "htmx" | "ignored" | "angular" | "unknown";

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

@@ -0,0 +1,2 @@
+export type ComponentType = 'client' | 'server';
+export declare const classifyComponent: (filePath: string) => "client" | "server";

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

@@ -0,0 +1,10 @@
+import type { BuildConfig } from '../../types/build';
+import type { HMRState } from './clientManager';
+export declare const queueFileChange: (state: HMRState, filePath: string, config: BuildConfig, onRebuildComplete: (result: {
+    manifest: Record<string, string>;
+    hmrState: HMRState;
+}) => void) => void;
+export declare const triggerRebuild: (state: HMRState, config: BuildConfig, onRebuildComplete: (result: {
+    manifest: Record<string, string>;
+    hmrState: HMRState;
+}) => void, filesToRebuild?: string[]) => Promise<Record<string, string> | null>;

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

@@ -0,0 +1,4 @@
+export declare const handleHTMLUpdate: (htmlFilePath: string) => Promise<string | {
+    body: string;
+    head: string | null;
+} | null>;

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

@@ -0,0 +1,4 @@
+export declare const handleHTMXUpdate: (htmxFilePath: string) => Promise<string | {
+    body: string;
+    head: string | null;
+} | null>;

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

@@ -0,0 +1 @@
+export declare const handleSvelteUpdate: (svelteFilePath: string, manifest: Record<string, string>, buildDir?: string) => Promise<string | null>;

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

@@ -0,0 +1 @@
+export declare const handleVueUpdate: (vueFilePath: string, manifest: Record<string, string>, buildDir?: string) => Promise<string | null>;

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

@@ -0,0 +1,9 @@
+import type { HMRState } from './clientManager';
+import type { HMRWebSocket } from '../../types/websocket';
+export declare const handleClientConnect: (state: HMRState, client: HMRWebSocket, manifest: Record<string, string>) => void;
+export declare const handleClientDisconnect: (state: HMRState, client: HMRWebSocket) => void;
+export declare const handleHMRMessage: (state: HMRState, client: HMRWebSocket, message: unknown) => void;
+export declare const broadcastToClients: (state: HMRState, message: {
+    type: string;
+    [key: string]: any;
+}) => void;

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../types';
+export * from './constants';
+export * from './core';
+export * from './plugins/index';
+export * from './utils/index';

package/dist/src/plugins/hmr.d.ts

@@ -0,0 +1,62 @@
+import Elysia from 'elysia';
+import { HMRState } from '../dev/clientManager';
+export declare const hmr: (hmrState: HMRState, manifest: Record<string, string>) => (app: Elysia) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    hmr: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    "hmr-status": {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | {
+                    connectedClients: number;
+                    isRebuilding: boolean;
+                    manifestKeys: string[];
+                    rebuildQueue: string[];
+                    timestamp: number;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response;
+    };
+}>;

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

@@ -0,0 +1,3 @@
+export * from './pageRouter';
+export * from './hmr';
+export * from './networking';

package/dist/src/plugins/networking.d.ts

@@ -0,0 +1,29 @@
+import { Elysia } from 'elysia';
+export declare const networking: (app: Elysia) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/src/plugins/pageRouter.d.ts

@@ -0,0 +1 @@
+export declare const pageRouterPlugin: () => void;

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

@@ -0,0 +1,12 @@
+import { Readable } from 'node:stream';
+import type { Component } from 'svelte';
+export type RenderPipeableOptions = {
+    bootstrapScriptContent?: string;
+    bootstrapScripts?: string[];
+    bootstrapModules?: string[];
+    nonce?: string;
+    onError?: (error: unknown) => void;
+    progressiveChunkSize?: number;
+    signal?: AbortSignal;
+};
+export declare const renderToPipeableStream: <Props extends Record<string, unknown> = Record<string, never>>(component: Component<Props>, props?: Props, { bootstrapScriptContent, bootstrapScripts, bootstrapModules, nonce, onError, progressiveChunkSize, signal }?: RenderPipeableOptions) => Readable;

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

@@ -0,0 +1,13 @@
+import type { Component } from 'svelte';
+export type RenderStreamOptions = {
+    bootstrapScriptContent?: string;
+    bootstrapScripts?: string[];
+    bootstrapModules?: string[];
+    nonce?: string;
+    onError?: (error: unknown) => void;
+    progressiveChunkSize?: number;
+    signal?: AbortSignal;
+    headContent?: string;
+    bodyContent?: string;
+};
+export declare const renderToReadableStream: <Props extends Record<string, unknown> = Record<string, never>>(component: Component<Props>, props?: Props, { bootstrapScriptContent, bootstrapScripts, bootstrapModules, nonce, onError, progressiveChunkSize, signal, headContent, bodyContent }?: RenderStreamOptions) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;

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

@@ -0,0 +1,9 @@
+import type { Component } from 'svelte';
+export type RenderStringOptions = {
+    bootstrapScriptContent?: string;
+    bootstrapScripts?: string[];
+    bootstrapModules?: string[];
+    nonce?: string;
+    onError?: (error: unknown) => void;
+};
+export declare const renderToString: <Props extends Record<string, unknown> = Record<string, never>>(component: Component<Props>, props?: Props, { bootstrapScriptContent, bootstrapScripts, bootstrapModules, nonce, onError }?: RenderStringOptions) => string;

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

@@ -0,0 +1,7 @@
+type CleanupProps = {
+    svelteDir?: string;
+    vueDir?: string;
+    reactIndexesPath?: string;
+};
+export declare const cleanup: ({ svelteDir, vueDir, reactIndexesPath }: CleanupProps) => Promise<void>;
+export {};

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

@@ -0,0 +1 @@
+export declare const commonAncestor: (paths: string[], fallback?: string) => string | undefined;

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

@@ -0,0 +1 @@
+export declare const escapeScriptContent: (content: string) => string;

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

@@ -0,0 +1,17 @@
+type GenerateHeadElementProps = {
+    cssPath?: string;
+    title?: string;
+    icon?: string;
+    description?: string;
+    font?: string;
+};
+export declare const generateHeadElement: ({ cssPath, title, description, font, icon }?: GenerateHeadElementProps) => `<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${string}</title>
+  <meta name="description" content="${string}">
+  <link rel="icon" href="${string}" type="image/x-icon">
+  ${string}
+  ${string}
+</head>`;
+export {};

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

@@ -0,0 +1 @@
+export declare const getDurationString: (duration: number) => string;

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

@@ -0,0 +1 @@
+export declare const getEnv: (key: string) => string;

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

@@ -0,0 +1,10 @@
+/**
+ * Type-safe helper to get the registerClientScript function during SSR.
+ *
+ * This function safely accesses the global registerClientScript that's made
+ * available during Angular SSR rendering. It returns null if not available
+ * (e.g., when running outside of SSR context).
+ *
+ * @returns The registerClientScript function if available, null otherwise
+ */
+export declare const getRegisterClientScript: () => ((script: () => void) => string) | null;

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

@@ -0,0 +1,6 @@
+export * from './networking';
+export * from '../build/updateAssetPaths';
+export * from './generateHeadElement';
+export * from './getEnv';
+export * from './registerClientScript';
+export * from './getRegisterClientScript';

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

@@ -0,0 +1,54 @@
+/**
+ * Centralized logger utility for AbsoluteJS
+ * Provides formatted output with ANSI colors and timestamps
+ */
+export declare const logger: {
+    /**
+     * HMR update message
+     * Format: "10:30:45 AM [hmr] hmr update /pages/App.tsx"
+     */
+    hmrUpdate(path: string, framework?: string, duration?: number): void;
+    /**
+     * Page reload message
+     * Format: "10:30:45 AM [hmr] page reload /src/App.tsx (125ms)"
+     */
+    pageReload(path: string, framework?: string, duration?: number): void;
+    /**
+     * CSS update message
+     * Format: "10:30:45 AM [hmr] css update /styles/main.css (125ms)"
+     */
+    cssUpdate(path: string, framework?: string, duration?: number): void;
+    /**
+     * Script update message
+     * Format: "10:30:45 AM [hmr] script update /scripts/counter.ts (125ms)"
+     */
+    scriptUpdate(path: string, framework?: string, duration?: number): void;
+    /**
+     * Build error
+     * Format: "10:30:45 AM [hmr] error Build failed: ..."
+     */
+    error(message: string, error?: Error | string): void;
+    /**
+     * Warning message
+     * Format: "10:30:45 AM [hmr] warning ..."
+     */
+    warn(message: string): void;
+    /**
+     * Generic info message
+     */
+    info(message: string): void;
+    /**
+     * Server module reloaded (Bun --hot triggered a server-side change)
+     */
+    serverReload(): void;
+    /**
+     * Startup banner
+     */
+    ready: (options: {
+        version: string;
+        duration: number;
+        port: string | number;
+        host: string;
+        networkUrl?: string;
+    }) => void;
+};

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

@@ -0,0 +1,2 @@
+export declare const getAllNetworkIPs: () => string[];
+export declare const getLocalIPAddress: () => string;