@absolutejs/absolute 0.19.0-beta.1043 → 0.19.0-beta.1044

package/dist/types/messages.d.ts

@@ -0,0 +1,152 @@
+export type PingMessage = {
+    type: 'ping';
+};
+export type ReadyMessage = {
+    type: 'ready';
+    framework?: string | null;
+};
+export type RequestRebuildMessage = {
+    type: 'request-rebuild';
+};
+export type HydrationErrorMessage = {
+    type: 'hydration-error';
+    data?: {
+        componentName?: string;
+        componentPath?: string;
+        error?: string;
+    };
+};
+export type HMRTimingMessage = {
+    type: 'hmr-timing';
+    duration: number;
+};
+export type AngularHmrAckMessage = {
+    type: 'angular:hmr-ack';
+    id: string;
+    className: string;
+    tier: 'tier-0' | 'tier-1a';
+    applyMs: number;
+    error?: string;
+};
+export type HMRClientMessage = PingMessage | ReadyMessage | RequestRebuildMessage | HydrationErrorMessage | HMRTimingMessage | AngularHmrAckMessage;
+export type ManifestMessage = {
+    type: 'manifest';
+    data: {
+        manifest: Record<string, string>;
+        serverVersions?: Record<string, number>;
+    };
+    timestamp: number;
+};
+export type RebuildStartMessage = {
+    type: 'rebuild-start';
+    data: {
+        affectedFrameworks: string[];
+    };
+    timestamp: number;
+};
+export type RebuildCompleteMessage = {
+    type: 'rebuild-complete';
+    data: {
+        affectedFrameworks: string[];
+        manifest: Record<string, string>;
+    };
+    timestamp: number;
+};
+export type FrameworkUpdateMessage = {
+    type: 'framework-update';
+    data: {
+        framework: string;
+        manifest?: Record<string, string>;
+    };
+    timestamp: number;
+};
+export type ModuleUpdateMessage = {
+    type: 'module-update';
+    data: {
+        framework: string;
+        manifest?: Record<string, string>;
+        modules?: Array<{
+            sourceFile: string;
+            moduleKeys: string[];
+            modulePaths: Record<string, string>;
+            componentType?: 'client' | 'server';
+            version?: number;
+        }>;
+        moduleVersions?: Record<string, number>;
+        serverVersions?: Record<string, number>;
+    };
+    timestamp: number;
+};
+export type ReactUpdateMessage = {
+    type: 'react-update';
+    data: {
+        sourceFile: string;
+        html?: string;
+        manifest?: Record<string, string>;
+    };
+    timestamp: number;
+};
+export type HTMLUpdateMessage = {
+    type: 'html-update';
+    data: {
+        sourceFile: string;
+        html?: string;
+    };
+    timestamp: number;
+};
+export type HTMXUpdateMessage = {
+    type: 'htmx-update';
+    data: {
+        sourceFile: string;
+        html?: string;
+    };
+    timestamp: number;
+};
+export type SvelteUpdateMessage = {
+    type: 'svelte-update';
+    data: {
+        sourceFile: string;
+        html?: string;
+        manifest?: Record<string, string>;
+        cssUrl?: string;
+        cssBaseName?: string;
+        updateType?: string;
+    };
+    timestamp: number;
+};
+export type VueUpdateMessage = {
+    type: 'vue-update';
+    data: {
+        sourceFile: string;
+        html?: string;
+        manifest?: Record<string, string>;
+        hmrId?: string;
+        changeType?: 'style-only' | 'template-only' | 'script' | 'full';
+        componentPath?: string;
+        cssUrl?: string;
+        cssBaseName?: string;
+        forceReload?: boolean;
+        pageModuleUrl?: string;
+        serverDuration?: number;
+        updateType?: 'css-only' | 'full';
+    };
+    timestamp: number;
+};
+export type RebuildErrorMessage = {
+    type: 'rebuild-error';
+    data: {
+        affectedFrameworks: string[];
+        error: string;
+    };
+    timestamp: number;
+};
+export type PongMessage = {
+    type: 'pong';
+    timestamp: number;
+};
+export type ConnectedMessage = {
+    type: 'connected';
+    message?: string;
+    timestamp: number;
+};
+export type HMRServerMessage = ManifestMessage | RebuildStartMessage | RebuildCompleteMessage | FrameworkUpdateMessage | ModuleUpdateMessage | ReactUpdateMessage | HTMLUpdateMessage | HTMXUpdateMessage | SvelteUpdateMessage | VueUpdateMessage | RebuildErrorMessage | PongMessage | ConnectedMessage;

package/dist/types/metadata.d.ts

@@ -0,0 +1,51 @@
+export type OpenGraph = {
+    title?: string;
+    description?: string;
+    url?: string;
+    image?: string;
+    imageAlt?: string;
+    imageWidth?: number;
+    imageHeight?: number;
+    type?: 'website' | 'article' | 'profile' | (string & {});
+    siteName?: string;
+    locale?: string;
+};
+export type TwitterCard = {
+    card?: 'summary' | 'summary_large_image' | 'player' | 'app';
+    title?: string;
+    description?: string;
+    image?: string;
+    imageAlt?: string;
+    site?: string;
+    creator?: string;
+};
+export type RobotsDirective = {
+    index?: boolean;
+    follow?: boolean;
+    noarchive?: boolean;
+    nosnippet?: boolean;
+    noimageindex?: boolean;
+    maxSnippet?: number;
+    maxImagePreview?: 'none' | 'standard' | 'large';
+    maxVideoPreview?: number;
+};
+export type MetaTag = {
+    name?: string;
+    property?: string;
+    httpEquiv?: 'accept-ch' | 'content-security-policy' | 'content-type' | 'default-style' | 'refresh' | 'x-ua-compatible';
+    content: string;
+};
+import type { JsonLdSchema } from './jsonLd';
+export type Metadata = {
+    title?: string;
+    description?: string;
+    icon?: string;
+    font?: string;
+    cssPath?: string | string[];
+    canonical?: string;
+    openGraph?: OpenGraph;
+    twitter?: TwitterCard;
+    robots?: RobotsDirective;
+    meta?: MetaTag[];
+    jsonLd?: JsonLdSchema | JsonLdSchema[];
+};

package/dist/types/packageJson.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The shape of a `package.json`. Canonical home for this type — also consumed
+ * by create-absolutejs (which imports it from `@absolutejs/absolute`) and by the
+ * `absolute config` package.json panel.
+ */
+export type PackageJson = {
+    name: string;
+    version: string;
+    description?: string;
+    keywords?: string[];
+    main?: string;
+    module?: string;
+    browser?: string | Record<string, string>;
+    types?: string;
+    typings?: string;
+    exports?: string | Record<string, string | Record<string, string>>;
+    imports?: Record<string, string>;
+    bin?: string | Record<string, string>;
+    files?: string[];
+    scripts?: Record<string, string>;
+    private?: boolean;
+    publishConfig?: {
+        registry?: string;
+        [key: string]: unknown;
+    };
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    bundledDependencies?: string[];
+    bundleDependencies?: string[];
+    engines?: {
+        node?: string;
+        npm?: string;
+        [key: string]: string | undefined;
+    };
+    os?: string[];
+    cpu?: string[];
+    workspaces?: string[] | {
+        packages: string[];
+        nohoist?: string[];
+    };
+    repository?: string | {
+        type?: 'git' | string;
+        url: string;
+        directory?: string;
+    };
+    bugs?: string | {
+        url?: string;
+        email?: string;
+    };
+    homepage?: string;
+    author?: string | {
+        name: string;
+        email?: string;
+        url?: string;
+    };
+    contributors?: Array<string | {
+        name: string;
+        email?: string;
+        url?: string;
+    }>;
+    license?: string;
+    funding?: string | Array<{
+        type?: string;
+        url: string;
+    }>;
+    preferGlobal?: boolean;
+    sideEffects?: boolean | string[];
+    config?: Record<string, unknown>;
+    resolution?: Record<string, string>;
+    resolutions?: Record<string, string>;
+    [customField: string]: unknown;
+};

package/dist/types/packageJsonPanel.d.ts

@@ -0,0 +1,29 @@
+import type { FieldNode } from './config';
+export type PackageScript = {
+    command: string;
+    name: string;
+};
+export type PackageJsonState = {
+    configPath: string | null;
+    /** Top-level values present in the file (excluding `scripts`). */
+    current: Record<string, unknown>;
+    /** Field catalog from the PackageJson type + any extra keys in the file. */
+    fields: FieldNode[];
+    scripts: PackageScript[];
+};
+export type PackageScriptEdit = {
+    command?: string;
+    name: string;
+    remove?: boolean;
+    rename?: string;
+};
+export type PackageFieldEdit = {
+    name: string;
+    remove?: boolean;
+    value?: unknown;
+};
+export type PackageJsonEditResult = {
+    message: string;
+    ok: boolean;
+    state: PackageJsonState | null;
+};

package/dist/types/prettier.d.ts

@@ -0,0 +1,26 @@
+import type { SupportOption } from 'prettier';
+/** `json` = an editable JSON config (.prettierrc/.prettierrc.json) · `package`
+ *  = the `prettier` key in package.json · `other` = a JS/YAML config we won't
+ *  rewrite · `none` = no config yet (edits create .prettierrc.json). */
+export type PrettierFormat = 'json' | 'package' | 'other' | 'none';
+export type PrettierState = {
+    /** False when prettier can't be resolved at runtime (not installed). */
+    available: boolean;
+    categories: string[];
+    configPath: string | null;
+    current: Record<string, unknown>;
+    editable: boolean;
+    format: PrettierFormat;
+    /** Option metadata straight from `prettier.getSupportInfo()`. */
+    options: SupportOption[];
+};
+export type PrettierEditRequest = {
+    name: string;
+    remove?: boolean;
+    value?: unknown;
+};
+export type PrettierEditResult = {
+    message: string;
+    ok: boolean;
+    state: PrettierState | null;
+};

package/dist/types/react.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentType as ReactComponent } from 'react';
+export type ReactPropsOf<C> = C extends ReactComponent<infer P> ? P : Record<string, never>;

package/dist/types/sitemap.d.ts

@@ -0,0 +1,24 @@
+export type ChangeFrequency = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+export type SitemapRouteOverride = {
+    changefreq?: ChangeFrequency;
+    priority?: number;
+    lastmod?: string;
+    /** Per-route opt-out. When set on a page handler's `sitemap` block
+     *  (e.g. `sitemap: { exclude: true }`), the route is omitted from
+     *  the generated sitemap.xml. Use for auth-gated routes, token
+     *  pages, or anything that shouldn't be crawled. */
+    exclude?: boolean;
+};
+/** Per-route sitemap metadata, accepted as an optional `sitemap` field
+ *  on every framework page-handler input (`handleAngularPageRequest`,
+ *  `handleReactPageRequest`, etc.). Statically read off the handler
+ *  source at registration time. */
+export type PageHandlerSitemapMetadata = SitemapRouteOverride;
+export type SitemapConfig = {
+    baseUrl?: string;
+    exclude?: (string | RegExp)[];
+    defaultChangefreq?: ChangeFrequency;
+    defaultPriority?: number;
+    overrides?: Record<string, SitemapRouteOverride>;
+    routes?: () => string[] | Promise<string[]>;
+};

package/dist/types/style-module-shim.d.ts

@@ -0,0 +1,29 @@
+declare module '*.module.scss' {
+	const classes: Readonly<Record<string, string>>;
+
+	export default classes;
+}
+
+declare module '*.module.sass' {
+	const classes: Readonly<Record<string, string>>;
+
+	export default classes;
+}
+
+declare module '*.module.less' {
+	const classes: Readonly<Record<string, string>>;
+
+	export default classes;
+}
+
+declare module '*.module.styl' {
+	const classes: Readonly<Record<string, string>>;
+
+	export default classes;
+}
+
+declare module '*.module.stylus' {
+	const classes: Readonly<Record<string, string>>;
+
+	export default classes;
+}

package/dist/types/svelte.d.ts

@@ -0,0 +1,2 @@
+import type { Component as SvelteComponent } from 'svelte';
+export type SveltePropsOf<C> = C extends SvelteComponent<infer P> ? P : Record<string, never>;

package/dist/types/svelteRouter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Public type surface for the AbsoluteJS Svelte router.
+ *
+ * `ExtractRouteParams<P>` walks a path-pattern string literal and produces
+ * a typed `params` shape:
+ *
+ *   ExtractRouteParams<'/users/:id'>            → { id: string }
+ *   ExtractRouteParams<'/users/:id/posts/:pid'> → { id: string; pid: string }
+ *   ExtractRouteParams<'/users/:id?'>           → { id: string | undefined }
+ *   ExtractRouteParams<'/files/*'>              → { wildcard: string }
+ *   ExtractRouteParams<'/dashboard'>            → Record<string, never>
+ *
+ * Edge cases:
+ *  - Optional params (`:name?`) appear as `string | undefined`
+ *  - Wildcard tail (`*`) is exposed as the `wildcard` key
+ *  - Same-name twice in one path is intentionally not detected at the type
+ *    level (it's a logic bug in the user's pattern, not something the type
+ *    system meaningfully rescues).
+ */
+type IsOptionalParamSegment<Segment extends string> = Segment extends `${string}?` ? true : false;
+type StripOptionalSuffix<Segment extends string> = Segment extends `${infer Name}?` ? Name : Segment;
+type WildcardSegment = '*' | `*${string}`;
+type ParseSegment<Segment extends string> = Segment extends WildcardSegment ? {
+    wildcard: string;
+} : Segment extends `:${infer Name}` ? IsOptionalParamSegment<Name> extends true ? {
+    [K in StripOptionalSuffix<Name>]: string | undefined;
+} : {
+    [K in Name]: string;
+} : Record<never, never>;
+type SplitPath<Path extends string> = Path extends `/${infer Rest}` ? SplitPath<Rest> : Path extends `${infer Head}/${infer Tail}` ? ParseSegment<Head> & SplitPath<Tail> : ParseSegment<Path>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type ExtractRouteParams<Path extends string> = string extends Path ? Record<string, string> : Simplify<SplitPath<Path>> extends infer Result ? keyof Result extends never ? Record<string, never> : Result : never;
+export type RouteMatch<Params extends Record<string, unknown>> = {
+    matched: true;
+    params: Params;
+};
+export type RouteMiss = {
+    matched: false;
+};
+export type RouteMatchResult<Params extends Record<string, unknown>> = RouteMatch<Params> | RouteMiss;
+export type RouterMode = 'history' | 'hash';
+export type GotoOptions = {
+    /** Use `history.replaceState` instead of `pushState`. */
+    replaceState?: boolean;
+    /** Don't reset focus to body on navigation. */
+    keepFocus?: boolean;
+    /** Don't scroll to top on navigation. */
+    noScroll?: boolean;
+    /** Value attached to `history.state`. */
+    state?: unknown;
+};
+export type LinkPrefetchMode = 'hover' | 'viewport' | 'none';
+export type PageState = {
+    url: URL;
+    params: Record<string, string | undefined>;
+    state: unknown;
+};
+export type RouterContextValue = {
+    /** Stacked basepath from outer to inner Router (joined). */
+    basepath: string;
+    mode: RouterMode;
+};
+export {};

package/dist/types/svelteRouter.ts

@@ -0,0 +1,91 @@
+/**
+ * Public type surface for the AbsoluteJS Svelte router.
+ *
+ * `ExtractRouteParams<P>` walks a path-pattern string literal and produces
+ * a typed `params` shape:
+ *
+ *   ExtractRouteParams<'/users/:id'>            → { id: string }
+ *   ExtractRouteParams<'/users/:id/posts/:pid'> → { id: string; pid: string }
+ *   ExtractRouteParams<'/users/:id?'>           → { id: string | undefined }
+ *   ExtractRouteParams<'/files/*'>              → { wildcard: string }
+ *   ExtractRouteParams<'/dashboard'>            → Record<string, never>
+ *
+ * Edge cases:
+ *  - Optional params (`:name?`) appear as `string | undefined`
+ *  - Wildcard tail (`*`) is exposed as the `wildcard` key
+ *  - Same-name twice in one path is intentionally not detected at the type
+ *    level (it's a logic bug in the user's pattern, not something the type
+ *    system meaningfully rescues).
+ */
+
+type IsOptionalParamSegment<Segment extends string> =
+	Segment extends `${string}?` ? true : false;
+
+type StripOptionalSuffix<Segment extends string> =
+	Segment extends `${infer Name}?` ? Name : Segment;
+
+type WildcardSegment = '*' | `*${string}`;
+
+type ParseSegment<Segment extends string> = Segment extends WildcardSegment
+	? { wildcard: string }
+	: Segment extends `:${infer Name}`
+		? IsOptionalParamSegment<Name> extends true
+			? { [K in StripOptionalSuffix<Name>]: string | undefined }
+			: { [K in Name]: string }
+		: Record<never, never>;
+
+type SplitPath<Path extends string> = Path extends `/${infer Rest}`
+	? SplitPath<Rest>
+	: Path extends `${infer Head}/${infer Tail}`
+		? ParseSegment<Head> & SplitPath<Tail>
+		: ParseSegment<Path>;
+
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+
+export type ExtractRouteParams<Path extends string> = string extends Path
+	? Record<string, string>
+	: Simplify<SplitPath<Path>> extends infer Result
+		? keyof Result extends never
+			? Record<string, never>
+			: Result
+		: never;
+
+export type RouteMatch<Params extends Record<string, unknown>> = {
+	matched: true;
+	params: Params;
+};
+
+export type RouteMiss = {
+	matched: false;
+};
+
+export type RouteMatchResult<Params extends Record<string, unknown>> =
+	| RouteMatch<Params>
+	| RouteMiss;
+
+export type RouterMode = 'history' | 'hash';
+
+export type GotoOptions = {
+	/** Use `history.replaceState` instead of `pushState`. */
+	replaceState?: boolean;
+	/** Don't reset focus to body on navigation. */
+	keepFocus?: boolean;
+	/** Don't scroll to top on navigation. */
+	noScroll?: boolean;
+	/** Value attached to `history.state`. */
+	state?: unknown;
+};
+
+export type LinkPrefetchMode = 'hover' | 'viewport' | 'none';
+
+export type PageState = {
+	url: URL;
+	params: Record<string, string | undefined>;
+	state: unknown;
+};
+
+export type RouterContextValue = {
+	/** Stacked basepath from outer to inner Router (joined). */
+	basepath: string;
+	mode: RouterMode;
+};

package/dist/types/telemetry.d.ts

@@ -0,0 +1,15 @@
+export type TelemetryConfig = {
+    enabled: boolean;
+    anonymousId: string;
+    createdAt: string;
+};
+export type TelemetryEvent = {
+    event: string;
+    anonymousId: string;
+    version: string;
+    os: string;
+    arch: string;
+    bunVersion: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+};

package/dist/types/tool.d.ts

@@ -0,0 +1,11 @@
+export type ToolCacheData = {
+    configHash: string;
+    files: Record<string, string>;
+};
+export type ToolAdapter = {
+    name: string;
+    fileGlobs: string[];
+    ignorePatterns: string[];
+    configFiles: string[];
+    buildCommand: (files: string[], args: string[]) => string[];
+};

package/dist/types/tsconfig.d.ts

@@ -0,0 +1,31 @@
+export type TsOptionKind = 'boolean' | 'string' | 'number' | 'enum' | 'list';
+export type TsOption = {
+    /** TypeScript's own option category, e.g. "Type Checking", "Modules". */
+    category: string;
+    /** Human description of the compiler default, when TypeScript provides one. */
+    defaultLabel: string;
+    description: string;
+    /** Allowed values for `enum` kinds (and element values for enum `list`s). */
+    enumValues: string[];
+    kind: TsOptionKind;
+    name: string;
+};
+export type TsConfigState = {
+    categories: string[];
+    /** `null` when no tsconfig/jsconfig was found in the project. */
+    configPath: string | null;
+    /** The literal `compilerOptions` written in the file (not resolved/inherited). */
+    current: Record<string, unknown>;
+    options: TsOption[];
+};
+export type TsEditRequest = {
+    name: string;
+    /** When true, delete the key from `compilerOptions` instead of setting it. */
+    remove?: boolean;
+    value?: unknown;
+};
+export type TsEditResult = {
+    message: string;
+    ok: boolean;
+    state: TsConfigState | null;
+};

package/dist/types/typeGuards.d.ts

@@ -0,0 +1,2 @@
+import type { HMRClientMessage } from './messages';
+export declare const isValidHMRClientMessage: (data: unknown) => data is HMRClientMessage;

package/dist/types/userAgentTypes.d.ts

@@ -0,0 +1,2 @@
+import { getUserAgentType } from '../src/utils/userAgentFunctions';
+export type UserAgentType = ReturnType<typeof getUserAgentType>;

package/dist/types/vue.d.ts

@@ -0,0 +1,56 @@
+import type { AllowedComponentProps, App, ComponentCustomProps, VNodeProps } from 'vue';
+/** Structural shape of vue-router we expose to user code. Keeps the helper
+ *  free of a hard dependency on `vue-router` types — users opt in to the
+ *  router by exporting `routes`, the package shouldn't pull a peer dep
+ *  type-check into every consumer. */
+export type VueAutoRouter = {
+    currentRoute: {
+        value: {
+            fullPath: string;
+        };
+    };
+    push: (to: string) => Promise<unknown>;
+    isReady: () => Promise<void>;
+    beforeEach: (guard: (to: unknown, from: unknown) => unknown) => () => void;
+};
+export type VueSetupAppContext = {
+    url: string;
+    isServer: boolean;
+    /** The vue-router instance AbsoluteJS auto-created from the page's
+     *  `routes` export, already installed on the app and navigated to
+     *  the request URL. `null` when the page didn't export `routes`. */
+    router: VueAutoRouter | null;
+    /** Server-only. Call to short-circuit SSR and emit an HTTP redirect
+     *  instead. Pass the destination location and an optional status
+     *  (defaults to `302`). */
+    setRedirect: (location: string, status?: number) => void;
+};
+export type VueSetupApp = (app: App, ctx: VueSetupAppContext) => void | Promise<void>;
+/** Structural shape of a single vue-router route record. Kept loose
+ *  because absolutejs doesn't depend on `vue-router` types — users who
+ *  want stricter typing can annotate with `RouteRecordRaw[]` from
+ *  vue-router themselves. */
+export type VueRouteRecord = {
+    path: string;
+    component?: unknown;
+    children?: VueRouteRecord[];
+    name?: string;
+    redirect?: string | {
+        name: string;
+    };
+    meta?: Record<string, unknown>;
+};
+export type VueRoutes = readonly VueRouteRecord[];
+type ReservedVueProps = keyof VNodeProps | keyof AllowedComponentProps | keyof ComponentCustomProps;
+export type VuePropsOf<C> = C extends new () => {
+    $props: infer Props;
+} ? Omit<Props, ReservedVueProps> : C extends (props: infer Props, ...args: never[]) => unknown ? Props extends Record<string, unknown> ? Props : Record<string, never> : Record<string, never>;
+export type VueVNode = {
+    children?: VueVNode[];
+    component?: VueComponentInstance;
+};
+export type VueComponentInstance = {
+    setupState?: Record<string, unknown>;
+    subTree?: VueVNode;
+};
+export {};

package/dist/types/websocket.d.ts

@@ -0,0 +1,6 @@
+export declare const WS_READY_STATE_OPEN = 1;
+export type HMRWebSocket = {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    readyState: number;
+};