@bleedingdev/modern-js-renderer-solid 0.0.0-stage → 3.9.3-ultramodern.1

package/dist/types/entry-server.d.ts

@@ -0,0 +1,5 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import { type NativeI18nInstance, type NativeServerEntry, type NativeServerEntryOptions } from '@modern-js/renderer-core/entry-server';
+export type SolidServerEntryOptions = NativeServerEntryOptions<NativeI18nInstance, LocalisedUrlsOption>;
+/** The native transport handlers of a generated Solid server entry. */
+export declare function createNativeServerEntry(options: SolidServerEntryOptions): NativeServerEntry;

package/dist/types/federation-context.d.ts

@@ -0,0 +1,16 @@
+import { type FederationInstance, type NativeFederationBinding } from '@modern-js/renderer-core/federation';
+import type { JSX } from '@solidjs/web';
+/** One application owns its host runtime; each response owns its render scope. */
+export interface SolidFederationScope {
+    readonly instance: FederationInstance | undefined;
+    /** Server scopes: the host's client module that hydrates a remote. */
+    readonly hydrationModule?: string;
+}
+/** Outside a generated entry, remote ids have no host; custom loaders work. */
+export declare const FederationContext: import("solid-js").Context<SolidFederationScope>;
+export declare function createFederationScope(binding: NativeFederationBinding | undefined): SolidFederationScope | undefined;
+/**
+ * Provide the scope to an application view. The server and the browser wrap
+ * the same view, so both render the provider at the same hydration position.
+ */
+export declare function provideFederation(scope: SolidFederationScope | undefined, view: () => JSX.Element): () => JSX.Element;

package/dist/types/federation-ssr.d.ts

@@ -0,0 +1,21 @@
+import type { SolidFederationScope } from './federation-context.js';
+/**
+ * The server half of same-renderer Module Federation. federatedComponent()
+ * names each remote it server-rendered by an asset key, and the response's
+ * document resolves that key through the same host's federation scope.
+ */
+/** Asset keys for server-rendered remotes, e.g. `ultramodern-federation:remote/Widget`. */
+export declare const FEDERATED_ASSET_PREFIX = "ultramodern-federation:";
+/** The host's server state for a remote: its browser assets and hydration module. */
+export declare function federatedServerAssets(scope: SolidFederationScope | undefined, id: string): {
+    hydration: string;
+    assets: import("@modern-js/renderer-core/federation").FederatedAssets;
+} | undefined;
+export declare function federatedAssetKey(id: string): string;
+/**
+ * Extend a static Solid asset manifest with the remotes this response
+ * server-rendered through its host. The first module is the host's hydration
+ * module for that remote, which Solid imports before hydrating the boundary
+ * that rendered it.
+ */
+export declare function withFederatedAssets<Manifest>(manifest: Manifest, scope: SolidFederationScope | undefined): Manifest;

package/dist/types/federation.d.ts

@@ -0,0 +1,30 @@
+import { type JSX } from '@solidjs/web';
+import { type Component } from 'solid-js';
+/** The module shape a same-renderer Module Federation remote exposes. */
+export interface FederatedModule<P extends object> {
+    readonly default: Component<P>;
+}
+export interface FederatedComponentOptions {
+    /** Rendered while the remote loads, and on the server when it cannot load. */
+    readonly fallback?: () => JSX.Element;
+    /**
+     * Milliseconds a remote load may take before it fails. Defaults to 3000 on
+     * the server, so an unavailable remote cannot hold the document; the
+     * browser waits without a limit unless one is given.
+     */
+    readonly timeout?: number;
+}
+/**
+ * Render a Solid component exposed by a Module Federation remote, by its
+ * `remote/Expose` id or a custom loader.
+ *
+ * A remote id loads through the federation instance of the application that
+ * renders it, so co-located hosts keep their own remotes. On the server it
+ * renders into the document with the remote's stylesheets and module
+ * preloads; the browser loads the same remote before hydrating it.
+ * A remote that fails or exceeds its timeout on the server renders the
+ * fallback, and the browser retries it after hydration. Custom loaders render
+ * in the browser only. Browser load and renderer-admission failures throw to
+ * the nearest `Errored` boundary.
+ */
+export declare function federatedComponent<P extends object = Record<string, never>>(remote: string | (() => Promise<FederatedModule<P>>), options?: FederatedComponentOptions): Component<P>;

package/dist/types/i18n/I18nProvider.d.ts

@@ -0,0 +1,21 @@
+import type { JSX } from '@solidjs/web';
+import type { I18nContextValue } from './types.js';
+export interface I18nProviderProps extends Omit<I18nContextValue, 'language'> {
+    children: JSX.Element;
+}
+/**
+ * Provides a per-request i18next-shaped instance to the Solid tree. The
+ * instance must come from the caller (created with `cloneInstance` per
+ * request on the server, and the same instance reused on hydration) — this
+ * provider holds no module-level state of its own beyond the one reactive
+ * `language` signal it derives from `instance` and shares with every
+ * consumer through context (see `I18nContextValue.language`'s doc for why
+ * that single shared subscription matters, instead of each consumer
+ * subscribing to `languageChanged` independently).
+ *
+ * In Solid 2 a `Context` doubles as its own provider component: `value` is
+ * read reactively off `props` here, so an ancestor re-rendering this
+ * provider with a new `instance`/`languages`/`localisedUrls` propagates
+ * without needing a `.Provider` subcomponent.
+ */
+export declare function I18nProvider(props: I18nProviderProps): JSX.Element;

package/dist/types/i18n/LocalizedLink.d.ts

@@ -0,0 +1,43 @@
+import type { JSX } from '@solidjs/web';
+import { type LinkComponentProps } from '../router.js';
+export interface LocalizedLinkProps {
+    /** A canonical, language-agnostic target, e.g. `/products/red-shoe`. */
+    to: string;
+    /** Localize for a specific language instead of the current one. */
+    language?: string;
+    children?: LinkComponentProps<'a'>['children'];
+    class?: string;
+    activeProps?: LinkComponentProps<'a'>['activeProps'];
+    inactiveProps?: LinkComponentProps<'a'>['inactiveProps'];
+    activeOptions?: LinkComponentProps<'a'>['activeOptions'];
+    replace?: boolean;
+    preload?: LinkComponentProps<'a'>['preload'];
+    [key: `data-${string}`]: unknown;
+}
+/**
+ * A thin wrapper over the native Solid router `Link` that localizes a
+ * canonical `to` for the current (or an explicit) language before handing it
+ * to the real link, the same contract as `@modern-js/plugin-i18n`'s React
+ * `Link`. It resolves the href itself via the shared pathname helpers, so it
+ * works with or without the router's i18n `rewrite`. Every link, including
+ * one to another language, is the native `Link`: navigation, preloading and
+ * active state stay with the router.
+ *
+ * Under the i18n `rewrite` the router matches canonical paths and localizes
+ * outgoing locations to the current language, so a link to another language
+ * routes to the canonical `to` and publishes the target language's URL as a
+ * route mask (the rewrite keeps a mask's explicit language). The entry's
+ * router language synchronization (`syncWithRouter`) switches the i18next
+ * instance from the navigated URL, as it does for history navigation.
+ *
+ * Props are forwarded explicitly (not via object-rest or a missing
+ * `splitProps`/`mergeProps` primitive — Solid 2 only exports `merge`) so
+ * each one is read directly from `props` in JSX position and keeps its
+ * per-key reactivity.
+ */
+export declare function LocalizedLink(props: LocalizedLinkProps): JSX.Element;
+/**
+ * Language-invariant active check: `to="/products"` is active whether the
+ * current location is `/en/products` or `/produkty` under a mapped locale.
+ */
+export declare function useIsLocalizedActive(canonicalTarget: string): () => boolean;

package/dist/types/i18n/context.d.ts

@@ -0,0 +1,11 @@
+import * as Solid from 'solid-js';
+import type { I18nContextValue } from './types.js';
+export type { I18nContextValue, I18nInstanceLike } from './types.js';
+/**
+ * Default-less form (Solid 2): `useContext` on this throws
+ * `ContextNotFoundError` when no `I18nProvider` is mounted, instead of
+ * silently reading a shared fallback instance across requests — exactly the
+ * failure mode a per-request i18n instance needs. The context object is
+ * itself the provider component: render `<I18nContext value={...}>`.
+ */
+export declare const I18nContext: Solid.Context<I18nContextValue>;

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,9 @@
+export { createRequestLanguageRedirect, detectRequestLanguage, languageFromPathname, type RequestLanguageDetection, type ResolvedRequestLanguage, type ResolveRequestLanguageOptions, resolveRequestLanguage, } from '@modern-js/i18n-runtime-extensions/request-language';
+export { createI18nSsrHandoffInlineData, I18N_SSR_HANDOFF_ELEMENT_ID, type I18nSsrHandoffPayload, type I18nSsrHandoffResources, readI18nSsrHandoff, } from '@modern-js/i18n-runtime-extensions/ssrLanguageHandoff';
+export { type CreateI18nUrlRewriteOptions, createI18nUrlRewrite, type I18nLocationRewrite, } from '@modern-js/i18n-runtime-extensions/urlRewrite';
+export { I18nContext } from './context.js';
+export { I18nProvider, type I18nProviderProps } from './I18nProvider.js';
+export { LocalizedLink, type LocalizedLinkProps, useIsLocalizedActive, } from './LocalizedLink.js';
+export { createLatestLanguageSync, type SolidLatestLanguageSyncOptions, } from './languageSync.js';
+export type { I18nContextValue, I18nInstanceLike } from './types.js';
+export { type UseI18nReturn, useI18n } from './useI18n.js';

package/dist/types/i18n/languageSync.d.ts

@@ -0,0 +1,31 @@
+import { type LanguageSyncFailure, type LanguageSyncPolicy } from '@modern-js/i18n-runtime-extensions/language-sync/controller';
+import * as Solid from 'solid-js';
+export interface SolidLatestLanguageSyncOptions<TTarget extends object> {
+    /** The sync target, e.g. the per-request i18next instance. Reactive. */
+    target: Solid.Accessor<TTarget | undefined>;
+    /** The language the URL (or other source of truth) currently wants. Reactive. */
+    desiredLanguage: Solid.Accessor<string | undefined>;
+    changeLanguage: (target: TTarget, language: string) => PromiseLike<unknown> | unknown;
+    commitLanguage: (target: TTarget, language: string) => void;
+    /** @default () => true */
+    enabled?: Solid.Accessor<boolean>;
+    policy?: LanguageSyncPolicy;
+    readLanguage?: (target: TTarget) => string | undefined;
+    reportFailure?: (failure: LanguageSyncFailure) => void;
+}
+/**
+ * Solid binding over the fork's renderer-neutral `Coordinator`/`Binding` pair
+ * (`@modern-js/i18n-runtime-extensions`'s `createLatestLanguageSyncBinding`):
+ * the same "latest intent wins, retry with backoff, report terminal failure"
+ * policy the React `useLatestLanguageSync` hook drives.
+ *
+ * Solid 2's `createEffect` has a compute/effect split (`compute(prev)` is
+ * tracked, `effect(next)` runs imperatively and may return a cleanup run
+ * before the next invocation or on disposal) rather than Solid 1's
+ * single-phase `createEffect(fn)` — reactive reads happen in `compute`,
+ * subscriptions happen in `effect`, which returns their cleanup.
+ *
+ * Returns a function to request a language change (e.g. from a language
+ * switcher), independent of the reactive `desiredLanguage` source.
+ */
+export declare function createLatestLanguageSync<TTarget extends object>(options: SolidLatestLanguageSyncOptions<TTarget>): (language: string) => void;

package/dist/types/i18n/types.d.ts

@@ -0,0 +1,33 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+/**
+ * The slice of an i18next-shaped instance this binding needs. Deliberately
+ * not `@modern-js/plugin-i18n`'s `I18nInstance`: that type is intentionally
+ * narrowed (no index signature, non-overloaded methods — see plugin-i18n's
+ * fork notes) and, more importantly, the plugin package's peer dependencies
+ * require React/ReactDOM, which a Solid-only application must never need to
+ * install. `on`/`off` are real i18next `EventEmitter` methods this interface
+ * adds back for the reactive `languageChanged` subscription.
+ */
+export interface I18nInstanceLike {
+    language: string;
+    t(key: string | string[], options?: Record<string, unknown>): string;
+    changeLanguage?(lng?: string): Promise<unknown> | unknown;
+    on?(event: 'languageChanged', callback: (lng: string) => void): void;
+    off?(event: 'languageChanged', callback: (lng: string) => void): void;
+    /** SSR per-request isolation: the server clones a base instance per request. */
+    cloneInstance?(options?: Record<string, unknown>): I18nInstanceLike;
+}
+export interface I18nContextValue {
+    /** Per-request instance. Never a module-level singleton. */
+    instance: I18nInstanceLike;
+    languages: readonly string[];
+    localisedUrls?: LocalisedUrlsOption;
+    /**
+     * Reactive current language, owned by `I18nProvider`. Every consumer
+     * (`useI18n`, `LocalizedLink`) reads this single shared signal rather than
+     * each subscribing to `instance`'s `languageChanged` event independently —
+     * `instance.language` is a plain mutable field, not itself reactive, so
+     * reading it directly would silently never update a Solid computation.
+     */
+    language: () => string;
+}

package/dist/types/i18n/useI18n.d.ts

@@ -0,0 +1,24 @@
+import * as Solid from 'solid-js';
+import type { I18nInstanceLike } from './types.js';
+export interface UseI18nReturn {
+    /** Reactive: re-evaluates when i18next fires `languageChanged`. */
+    t: I18nInstanceLike['t'];
+    /** Reactive current language accessor, shared with every other consumer. */
+    language: Solid.Accessor<string>;
+    languages: readonly string[];
+    /** The raw per-request instance, for advanced use (namespaces, `exists`, ...). */
+    instance: I18nInstanceLike;
+    /**
+     * Switches the i18next instance's language. Inside a router, also replaces
+     * the current URL with the localized path for the new language.
+     */
+    changeLanguage: (language: string) => Promise<void>;
+}
+/**
+ * Must render under `I18nProvider`; `useContext` on the default-less
+ * `I18nContext` throws `ContextNotFoundError` otherwise, rather than
+ * silently reading a fallback instance. The reactive `language` signal lives
+ * on the provider (one `languageChanged` subscription per request, shared by
+ * every consumer) — this hook just reads it.
+ */
+export declare function useI18n(): UseI18nReturn;

package/dist/types/index.d.ts

@@ -0,0 +1,41 @@
+/** This entry contains identity only. Select client, router or server explicitly. */
+export declare const SOLID_RENDERER_PROFILE: {
+    readonly renderer: 'solid';
+    readonly solid: '2.0.0-rc.13';
+    readonly web: '2.0.0-rc.13';
+    readonly router: '@modern-js/renderer-solid/router@3.8.3';
+    readonly routerSource: '4fbd65c5c3b40be87a6248867c22021c1c19bba8';
+    readonly routerCore: '1.171.34';
+    readonly history: '1.162.4';
+    readonly publicRouteData: {
+        readonly containers: readonly ['plain-record', 'null-record', 'array'];
+        readonly values: 'canonical-scalars';
+        readonly deferred: 'checked-top-level-native-promises';
+        readonly mutation: 'immutable-public-snapshot';
+        readonly unsupported: readonly ['Date', 'RegExp', 'Map', 'Set', 'AsyncIterable'];
+    };
+    readonly publicContext: {
+        readonly source: 'managed-constructor-route-context-and-before-load';
+        readonly providerOverrides: 'unsupported';
+    };
+    readonly nativePromiseMetadata: {
+        readonly runtime: '2.0.0-rc.13';
+        readonly fields: readonly ['s', 'v'];
+        readonly status: readonly [0, 1, 2];
+        readonly handle: 'sealed-with-checked-metadata';
+    };
+    readonly nativeRegistry: {
+        readonly source: 'managed-router-match-transfer';
+        readonly rawRejectedMatchInjection: 'unsupported';
+    };
+    readonly nativeRequestContext: {
+        readonly scope: 'complete-native-request-handler';
+        readonly event: 'one-per-request-session';
+    };
+    readonly nativeResponseHead: {
+        readonly statusText: 'fetch-response-status-text';
+        readonly terminalOutcome: 'authoritative';
+        readonly cache: 'intersect-with-session-policy';
+    };
+    readonly dataHttpTransport: 'renderer-core-rich-public-data';
+};

package/dist/types/manifest.d.ts

@@ -0,0 +1,55 @@
+import type { NativeCompilerArtifacts } from '@modern-js/renderer-core/adapter';
+import { type RendererIdentity } from '@modern-js/renderer-core/identity';
+export declare const SOLID_COMPILER_VERSION = "2.0.0-rc.13";
+export declare function solidModuleManifestFilename(entryName: string): string;
+/** The compiler's structural JSON boundary matches native Solid AssetManifest. */
+interface SolidPreloadAttributes {
+    type?: string;
+    crossorigin?: '' | true | 'anonymous' | 'use-credentials';
+    integrity?: string;
+    referrerpolicy?: 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+    fetchpriority?: 'high' | 'low' | 'auto';
+    media?: string;
+}
+export type SolidPreloadLink = SolidPreloadAttributes & ({
+    href: string;
+    as: 'fetch' | 'font' | 'script' | 'style' | 'track';
+    imagesrcset?: never;
+    imagesizes?: never;
+} | {
+    href: string;
+    as: 'image';
+    imagesrcset?: string;
+    imagesizes?: string;
+} | {
+    href?: never;
+    as: 'image';
+    imagesrcset: string;
+    imagesizes?: string;
+});
+export interface SolidAssetChunk {
+    file: string;
+    css?: string[];
+    imports?: string[];
+    isEntry?: boolean;
+    preloads?: SolidPreloadLink[];
+}
+export type SolidAssetManifest = Record<string, SolidAssetChunk> & {
+    _base?: string;
+};
+export interface SolidModuleManifest {
+    schemaVersion: 1;
+    renderer: 'solid';
+    compilerVersion: typeof SOLID_COMPILER_VERSION;
+    /** The shared source-build identity owner stamps this before runtime use. */
+    rendererIdentity: RendererIdentity;
+    modules: SolidAssetManifest;
+}
+export declare function validateSolidModuleManifest(value: unknown, expectedIdentity: RendererIdentity, requiredModuleKeys?: readonly string[]): SolidModuleManifest;
+/**
+ * The compiler artifact ABI. It lives in this runtime module, not in the
+ * build-only `./plugin`, because the production server validates manifests
+ * with it and deployments trace it from there.
+ */
+export declare const compilerArtifacts: NativeCompilerArtifacts;
+export {};

package/dist/types/native-promise-serialization.d.ts

@@ -0,0 +1,9 @@
+import { type SerovalNode } from '@solidjs/web/serialization';
+type PromiseInfo = {
+    resolver: SerovalNode;
+};
+/** Internal SSR-only native plugin. It is deliberately not an application
+ * codec or a public client decoder. Seroval owns indexing and settlement
+ * chunks; Solid retains its ordinary Promise, s/v and truncation semantics. */
+export declare const nativePromiseSerializationPlugin: import("@solidjs/web/serialization").SerializerPlugin<Promise<unknown>, PromiseInfo>;
+export {};

package/dist/types/plugin/compiler.d.ts

@@ -0,0 +1,6 @@
+import type { NativeRendererCompilerOptions } from '@modern-js/renderer-core/adapter';
+import type { RsbuildPlugin } from '@rsbuild/core';
+/** Private loaders remain in the package's shipped src tree in every format. */
+export declare function pluginSourceDirectory(): string;
+/** Own Solid's native compiler, refresh and lazy assets. */
+export declare function pluginSolidRenderer(options: NativeRendererCompilerOptions): RsbuildPlugin;

package/dist/types/plugin/create.d.ts

@@ -0,0 +1,21 @@
+export type SolidAppSourceOptions = {
+    appId: string;
+    title: string;
+    entryName?: string;
+    appRole?: 'shell' | 'vertical';
+    capabilities: {
+        ssr: boolean;
+        federation: boolean;
+    };
+};
+export type SolidAppSourceArtifact = {
+    path: string;
+    content: string;
+};
+export type SolidAppSources = {
+    sourceExtension: '.tsx';
+    jsxImportSource: '@solidjs/web';
+    artifacts: SolidAppSourceArtifact[];
+};
+/** The adapter owns the entry, route tree, document and hydration bootstrap. */
+export declare function generateSolidAppSources(options: SolidAppSourceOptions): SolidAppSources;

package/dist/types/plugin/index.d.ts

@@ -0,0 +1,3 @@
+import { type NativeRendererAdapter } from '@modern-js/renderer-core/adapter';
+/** The build-side Solid renderer adapter UltraModern loads for `renderer: 'solid'`. */
+export declare const rendererAdapter: NativeRendererAdapter<'solid'>;

package/dist/types/plugin/lazy-modules.d.cts

@@ -0,0 +1,15 @@
+declare const _exports: {
+    collectLazyModules: typeof collectLazyModules;
+    markerVisitor: typeof markerVisitor;
+    resolveLazyModule: typeof resolveLazyModule;
+};
+export = _exports;
+declare function resolveLazyModule(filename: any, specifier: any, projectRoot: any, sourceExtensions: string[] | undefined, dependencies: any): {
+    filename: string;
+    request: string;
+    key: string;
+};
+declare function markerVisitor(onMarker: any): {
+    StringLiteral(marker: any): void;
+};
+declare function collectLazyModules(projectRoot: any, entryDirectories: any[] | undefined, sourceExtensions: string[] | undefined, dependencies: any): any[];

package/dist/types/plugin/preserve-import-loader.d.cts

@@ -0,0 +1,3 @@
+export = preserveSolidImport;
+/** Preserve the native runtime's browser URL import without patching its file. */
+declare function preserveSolidImport(source: any, inputMap: any): void;

package/dist/types/plugin/profile.d.ts

@@ -0,0 +1,2 @@
+import type { RendererBuildProfile } from '@modern-js/renderer-core/adapter';
+export declare const solidProfile: RendererBuildProfile<'solid'>;

package/dist/types/plugin/solid-loader.d.cts

@@ -0,0 +1,2 @@
+export = solidLoader;
+declare function solidLoader(source: any, inputMap: any): Promise<void>;

package/dist/types/plugin/svg-component-template.d.cts

@@ -0,0 +1,6 @@
+export = _exports;
+declare function _exports({ attributes, markup, origin, }: {
+    attributes: any;
+    markup: any;
+    origin: any;
+}): string;

package/dist/types/route-completion.d.ts

@@ -0,0 +1,21 @@
+import type { RequestSession } from '@modern-js/renderer-core/session';
+import type { AnyRouter, CreateRouterFn } from '@tanstack/router-core';
+import type { AnyRoute, RouteComponent } from './router-binding/index.js';
+interface PublicDataGeneration {
+    readonly owner: Pick<RequestSession, 'fail' | 'signal'>;
+    publish(value: unknown, completion?: Promise<void>): void;
+}
+export interface RouteCompletionScope {
+    readonly hydrationOwner: Pick<RequestSession, 'fail' | 'signal'>;
+    readonly privateRoots: readonly object[];
+    attach(router: AnyRouter): void;
+    begin(signal: AbortSignal, cancel: () => void): PublicDataGeneration;
+    component(component: RouteComponent): RouteComponent;
+    dispose(): void;
+}
+export declare function registerRouteCompletionScope(route: AnyRoute, scope: RouteCompletionScope): void;
+export declare const createApplicationRouter: CreateRouterFn;
+export declare function ownApplicationRouteData(router: AnyRouter): void;
+/** A framing failure belongs to the exact native loader generation that read it. */
+export declare function createRouteCompletionScope(privateRoots?: readonly object[], session?: RequestSession): RouteCompletionScope;
+export {};

package/dist/types/route-data-error.d.ts

@@ -0,0 +1,17 @@
+import { RouteDataError } from '@modern-js/renderer-core/router';
+export interface RouteDataErrorSnapshot {
+    kind: 'ultramodern-route-data-error';
+    version: 1;
+    routeId: string;
+    status: number;
+    data: unknown;
+    error: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+/** Preserve the known public route error without serializing its Error object. */
+export declare function projectRouteDataError(error: unknown, production?: boolean): RouteDataErrorSnapshot;
+/** Reconstruct only the validated route error tag produced by this adapter. */
+export declare function restoreRouteDataError(snapshot: unknown): RouteDataError;

package/dist/types/router-binding/Asset.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from '@solidjs/web';
+import type { RouterManagedTag } from '@tanstack/router-core';
+export declare function Asset(asset: RouterManagedTag): JSX.Element | null;

package/dist/types/router-binding/CatchBoundary.d.ts

@@ -0,0 +1,13 @@
+import type { JSX } from '@solidjs/web';
+import * as Solid from 'solid-js';
+import type { ErrorRouteComponent } from './route.js';
+export declare function CatchBoundary(props: {
+    getResetKey: () => unknown;
+    children?: JSX.Element;
+    render?: () => JSX.Element;
+    errorComponent?: ErrorRouteComponent;
+    onCatch?: (error: Error) => void;
+} & Solid.ParentProps): JSX.Element;
+export declare function ErrorComponent({ error }: {
+    error: any;
+}): JSX.Element;

package/dist/types/router-binding/ClientOnly.d.ts

@@ -0,0 +1,31 @@
+import type { JSX } from '@solidjs/web';
+import * as Solid from 'solid-js';
+export interface ClientOnlyProps {
+    /**
+     * The children to render when the JS is loaded.
+     */
+    children: JSX.Element;
+    /**
+     * The fallback component to render if the JS is not yet loaded.
+     */
+    fallback?: JSX.Element;
+}
+/**
+ * Render the children only after the JS has loaded client-side. Use an optional
+ * fallback component if the JS is not yet loaded.
+ *
+ * @example
+ * Render a Chart component if JS loads, renders a simple FakeChart
+ * component server-side or if there is no JS. The FakeChart can have only the
+ * UI without the behavior or be a loading spinner or skeleton.
+ *
+ * ```tsx
+ * return (
+ *   <ClientOnly fallback={<FakeChart />}>
+ *     <Chart />
+ *   </ClientOnly>
+ * )
+ * ```
+ */
+export declare function ClientOnly(props: ClientOnlyProps): JSX.Element;
+export declare function useHydrated(): Solid.Accessor<boolean>;

package/dist/types/router-binding/HeadContent.d.ts

@@ -0,0 +1,13 @@
+import type { JSX } from '@solidjs/web';
+import type { AssetCrossOriginConfig } from '@tanstack/router-core';
+export interface HeadContentProps {
+    assetCrossOrigin?: AssetCrossOriginConfig;
+}
+/**
+ * @description The `HeadContent` component registers the current route's meta
+ * tags, links, and scripts with Solid's head registry, which owns emission
+ * into `<head>` (SSR splicing/streaming and client-side patching alike). It
+ * can be rendered anywhere in the tree, though placing it inside the `<head>`
+ * of your document keeps the hydration script in the right place.
+ */
+export declare function HeadContent(props: HeadContentProps): JSX.Element;

package/dist/types/router-binding/Match.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from '@solidjs/web';
+export declare const Match: (props: {
+    routeId: string;
+}) => JSX.Element;
+export declare const MatchInner: () => any;
+export declare const Outlet: () => JSX.Element;

package/dist/types/router-binding/Matches.d.ts

@@ -0,0 +1,26 @@
+import type { JSX } from '@solidjs/web';
+import type { AnyRouter, DeepPartial, Expand, MakeOptionalPathParams, MakeOptionalSearchParams, MakeRouteMatchUnion, MaskOptions, MatchRouteOptions, RegisteredRouter, ResolveRoute, ToSubOptionsProps } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+declare module '@tanstack/router-core' {
+    interface RouteMatchExtensions {
+        meta?: Array<JSX.IntrinsicElements['meta'] | undefined>;
+        links?: Array<JSX.IntrinsicElements['link'] | undefined>;
+        scripts?: Array<JSX.IntrinsicElements['script'] | undefined>;
+        styles?: Array<JSX.IntrinsicElements['style'] | undefined>;
+        headScripts?: Array<JSX.IntrinsicElements['script'] | undefined>;
+    }
+}
+export declare function Matches(): JSX.Element;
+export type UseMatchRouteOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = ''> = ToSubOptionsProps<TRouter, TFrom, TTo> & DeepPartial<MakeOptionalSearchParams<TRouter, TFrom, TTo>> & DeepPartial<MakeOptionalPathParams<TRouter, TFrom, TTo>> & MaskOptions<TRouter, TMaskFrom, TMaskTo> & MatchRouteOptions;
+export declare function useMatchRoute<TRouter extends AnyRouter = RegisteredRouter>(): <const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(opts: UseMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Solid.Accessor<false | Expand<ResolveRoute<TRouter, TFrom, TTo>['types']['allParams']>>;
+export type MakeMatchRouteOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = ''> = UseMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    children?: ((params?: Expand<ResolveRoute<TRouter, TFrom, TTo>['types']['allParams']>) => JSX.Element) | JSX.Element;
+};
+export declare function MatchRoute<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: MakeMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): any;
+export interface UseMatchesBaseOptions<TRouter extends AnyRouter, TSelected> {
+    select?: (matches: Array<MakeRouteMatchUnion<TRouter>>) => TSelected;
+}
+export type UseMatchesResult<TRouter extends AnyRouter, TSelected> = unknown extends TSelected ? Array<MakeRouteMatchUnion<TRouter>> : TSelected;
+export declare function useMatches<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseMatchesBaseOptions<TRouter, TSelected>): Solid.Accessor<UseMatchesResult<TRouter, TSelected>>;
+export declare function useParentMatches<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseMatchesBaseOptions<TRouter, TSelected>): Solid.Accessor<UseMatchesResult<TRouter, TSelected>>;
+export declare function useChildMatches<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseMatchesBaseOptions<TRouter, TSelected>): Solid.Accessor<UseMatchesResult<TRouter, TSelected>>;

package/dist/types/router-binding/RouterProvider.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from '@solidjs/web';
+import type { AnyRouter, RegisteredRouter, RouterOptions } from '@tanstack/router-core';
+export declare function RouterContextProvider<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>>({ router, children, ...rest }: RouterProps<TRouter, TDehydrated> & {
+    children: () => JSX.Element;
+}): JSX.Element;
+export declare function RouterProvider<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>>({ router, ...rest }: RouterProps<TRouter, TDehydrated>): JSX.Element;
+export type RouterProps<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>> = Omit<RouterOptions<TRouter['routeTree'], NonNullable<TRouter['options']['trailingSlash']>, false, TRouter['history'], TDehydrated>, 'context'> & {
+    router: TRouter;
+    context?: Partial<RouterOptions<TRouter['routeTree'], NonNullable<TRouter['options']['trailingSlash']>, false, TRouter['history'], TDehydrated>['context']>;
+};

package/dist/types/router-binding/SafeFragment.d.ts

@@ -0,0 +1,2 @@
+import type { JSX } from '@solidjs/web';
+export declare function SafeFragment(props: any): JSX.Element;

package/dist/types/router-binding/ScriptOnce.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from '@solidjs/web';
+export declare function ScriptOnce({ children, }: {
+    children: string;
+    log?: boolean;
+    sync?: boolean;
+}): JSX.Element;

package/dist/types/router-binding/Scripts.d.ts

@@ -0,0 +1,2 @@
+import type { JSX } from '@solidjs/web';
+export declare const Scripts: () => JSX.Element;

package/dist/types/router-binding/ScrollRestoration.d.ts

@@ -0,0 +1,14 @@
+import type { ParsedLocation, ScrollRestorationEntry, ScrollRestorationOptions } from '@tanstack/router-core';
+/**
+ * @deprecated use createRouter's `scrollRestoration` option instead
+ */
+export declare function ScrollRestoration(_props: ScrollRestorationOptions): null;
+export declare function useElementScrollRestoration(options: ({
+    id: string;
+    getElement?: () => Window | Element | undefined | null;
+} | {
+    id?: string;
+    getElement: () => Window | Element | undefined | null;
+}) & {
+    getKey?: (location: ParsedLocation) => string;
+}): ScrollRestorationEntry | undefined;