@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/dist/vite.d.ts

@@ -0,0 +1,661 @@
+import "solid-js";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Plugin, ViteDevServer } from "vite";
+//#region src/vite/auto-imports.d.ts
+/**
+ * Auto Imports
+ * Conservative transform: inject framework imports for configured identifiers
+ * that are used but not declared — the Nuxt auto-import equivalent
+ */
+export declare const FRAMEWORK_AUTO_IMPORTS: Record<string, string>;
+/**
+ * Returns the import statements to prepend, or null when nothing is needed.
+ * Only injects names that are (a) called/used, (b) not already imported,
+ * (c) not locally declared (const/let/function/class/import).
+ */
+export declare const injectAutoImports: (code: string, map: Record<string, string | string[]>) => string | null;
+//#endregion
+//#region src/render/types/index.d.ts
+type RenderMode = "ssr" | "stream" | "csr" | "islands";
+//#endregion
+//#region src/app/types/index.d.ts
+/**
+ * Per-route rendering/cache rules — the routeRules equivalent.
+ * Patterns support `*` (one segment) and `**` (any depth).
+ */
+interface RouteRule {
+  /**
+   * Render strategy — `data-only` runs the route loader on the server
+   * and ships a CSR shell with the data preloaded (TanStack Start's
+   * `ssr: 'data-only'` equivalent)
+   */
+  mode?: RenderMode | "ssg" | "prerender" | "data-only" | "ppr";
+  headers?: Record<string, string>;
+  /**
+   * Cache/ISR — maxAge is the revalidate window (seconds) for
+   * prerendered routes and the Cache-Control max-age
+   */
+  cache?: {
+    maxAge?: number;
+    swr?: boolean;
+    tags?: string[];
+  };
+  /**
+   * Per-route middleware — runs after config.middleware when this rule
+   * matches the request pathname. Return a Response to short-circuit.
+   */
+  middleware?: AppMiddleware[];
+  /**
+   * Security headers for matched routes — `true` applies the safe
+   * default set (nosniff, frame DENY, referrer policy, HSTS);
+   * `csp` enables a nonce-based Content-Security-Policy whose nonce
+   * is exposed as context.state.cspNonce and applied to the
+   * hydration script
+   */
+  security?: SecurityHeaders | boolean;
+  /**
+   * Rate limit — fixed-window token bucket per client key.
+   * `rpm` requests per `window` ms (default 60/60s); `key` customizes
+   * the bucket key (default: client ip + pattern)
+   */
+  rateLimit?: {
+    rpm?: number;
+    window?: number;
+    key?: (ctx: {
+      request: Request;
+    }) => string;
+  };
+  /**
+   * A/B split — `weight` fraction of clients are rewritten to
+   * `route` (sticky via `__ab_<pattern>` cookie)
+   */
+  variant?: {
+    route: string;
+    weight: number;
+  };
+  /**
+   * Sitemap metadata for matched routes — priority/changefreq/
+   * lastmod merge into the generated sitemap.xml entries
+   */
+  sitemap?: {
+    priority?: number;
+    changefreq?: string;
+    lastmod?: string;
+  };
+}
+interface SecurityHeaders {
+  /** CSP directives — {nonce} is replaced per request */
+  csp?: string | Record<string, string[]>;
+  /** X-Frame-Options — default DENY when security is enabled */
+  frameOptions?: "DENY" | "SAMEORIGIN";
+  /** Referrer-Policy — default strict-origin-when-cross-origin */
+  referrerPolicy?: string;
+  /** Strict-Transport-Security — default "max-age=31536000; includeSubDomains" */
+  hsts?: string;
+  /** X-Content-Type-Options: nosniff — default true */
+  noSniff?: boolean;
+}
+type RouteRules = Record<string, RouteRule>;
+/** Per-request state bag middleware writes into and render reads */
+interface MiddlewareContext<TState extends Record<string, unknown> = Record<string, unknown>> {
+  request: Request;
+  url: URL;
+  /** Shared state — exposed on the render context and route loaders */
+  state: TState;
+  /** Params from the matched file route, when available */
+  params?: Record<string, string>;
+}
+/**
+ * Server middleware — runs before routing/rendering. Return a Response
+ * to short-circuit (redirect, auth deny), otherwise call through.
+ * Generic over the shared state bag so downstream loaders/actions
+ * consume `state` type-safely via useRouteState<T>()
+ */
+type AppMiddleware<TState extends Record<string, unknown> = Record<string, unknown>> = ((ctx: MiddlewareContext<TState>) => undefined | Response | Promise<undefined | Response>) & {
+  /** Execution order — lower runs first; default 0 */
+  order?: number;
+};
+/** Framework plugin — the Nuxt-module equivalent */
+interface FrameworkPlugin {
+  name: string;
+  /** Mutate/patch resolved config at startup */
+  config?: (config: SolidFrameworkConfig) => Partial<SolidFrameworkConfig> | undefined;
+  /** Called when the file-route manifest is built (dev/build) */
+  routesResolved?: (manifest: unknown) => void;
+  /** Source transform hook inside the vite plugin */
+  transform?: (code: string, id: string) => string | null | undefined;
+}
+interface ImagesConfig {
+  /** Endpoint path — default "/_image" */
+  endpoint?: string;
+  /**
+   * Transformer port — receives parsed params, returns the optimized
+   * image Response. Default redirects to the original asset.
+   */
+  transformer?: (params: {
+    src: string;
+    width?: number;
+    quality?: number;
+    format?: string;
+    request: Request;
+  }) => Promise<Response> | Response;
+  /**
+   * Remote image allowlist (SSRF guard) — absolute `src` URLs are only
+   * fetched when the host matches a pattern ("cdn.example.com" or
+   * "*.example.com"). When unset, only same-origin sources resolve.
+   */
+  remotePatterns?: string[];
+}
+interface SolidFrameworkConfig {
+  /** Routes directory — default "src/routes" */
+  routesDir: string;
+  /** Default render mode when no route rule matches — default "stream" */
+  renderMode: RenderMode;
+  /** Path-pattern rules — `rules: { "/blog/**": { mode: "prerender" } }` */
+  rules: RouteRules;
+  /** @deprecated renamed to `rules` — routeRules is Nuxt's name */
+  routeRules?: RouteRules;
+  /** Path prefixes served by web-server API routes — default ["/api"] */
+  apiPrefixes: string[];
+  /** Default document metadata */
+  head: {
+    title?: string;
+    lang?: string;
+    /**
+     * Asset preload hints — entry chunks/styles emitted into <head> on
+     * every HTML response; pair with the build's preload-manifest.json
+     */
+    preloads?: string[];
+  };
+  /** Auto-import framework APIs in .tsx/.ts sources */
+  autoImports: boolean;
+  /** Server/client entry files */
+  entries: {
+    server: string;
+    client: string;
+  };
+  /** Extra public env prefixes exposed to the client — default ["PUBLIC_"] */
+  publicEnvPrefixes: string[];
+  /** Server middleware chain — runs before the render pipeline */
+  middleware?: AppMiddleware[];
+  /** Framework plugins */
+  plugins?: FrameworkPlugin[];
+  /**
+   * Layers — base configs merged shallow-first; this config wins.
+   * Compose app presets: `extends: [shopLayer]`
+   */
+  extends?: Partial<SolidFrameworkConfig>[];
+  /**
+   * Observability hooks — `instrumentation.ts` convention:
+   *   export const register = () => initTelemetry();
+   *   export const onRequest = (e) => span(e);
+   * register() runs once at server boot; onRequest runs after
+   * every response with {method, path, status, ms}
+   */
+  instrumentation?: {
+    register?: () => void | Promise<void>;
+    onRequest?: (event: {
+      method: string;
+      path: string;
+      status: number;
+      ms: number;
+    }) => void;
+    /** Thrown errors reach onError before the 500 response */
+    onError?: (event: {
+      method: string;
+      path: string;
+      error: unknown;
+    }) => void;
+  };
+  /**
+   * Multi-zone — requests under `prefix` proxy to `target` origin
+   * (another app/zone); prefix is stripped before forwarding
+   */
+  zones?: {
+    prefix: string;
+    target: string;
+  }[];
+  /** Image optimization endpoint config */
+  images?: ImagesConfig;
+  /**
+   * Build-time prerendering — after the SSR build, listed routes are
+   * rendered through the built server entry and written to outDir as
+   * static HTML. crawlLinks discovers additional pages via anchors.
+   */
+  prerender?: {
+    routes?: string[];
+    crawlLinks?: boolean;
+    /** Output directory for static pages — default "<root>/dist" */
+    outDir?: string;
+  };
+  /**
+   * Production static file serving — directories tried in order for
+   * GET requests before the render fallback (e.g. ["dist", "public"])
+   */
+  static?: {
+    dirs: string[];
+    immutablePrefix?: string;
+  };
+  /**
+   * PWA — emit sw.js (precache + cache-first GET strategy) and an
+   * optional manifest.webmanifest into the client build
+   */
+  pwa?: {
+    /** Extra URLs precached at install — "/" is always included */
+    precache?: string[];
+    manifest?: {
+      name?: string;
+      shortName?: string;
+      startUrl?: string;
+      display?: string;
+      background?: string;
+      theme?: string;
+      icons?: {
+        src: string;
+        sizes: string;
+        type?: string;
+      }[];
+    };
+  };
+  /**
+   * i18n routing — locale-prefixed paths (`/en/about`), stripped
+   * before route matching; locale exposed via useLocale()
+   */
+  i18n?: {
+    locales: string[];
+    defaultLocale: string;
+    strategy?: "prefix" | "prefix_except_default";
+  };
+}
+//#endregion
+//#region src/vite/dev-middleware.d.ts
+/**
+ * Vite middleware factory — SSRs page requests through the app server entry
+ */
+export declare const createSsrMiddleware: (server: ViteDevServer, config: SolidFrameworkConfig) => ((req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => void);
+//#endregion
+//#region src/router/shared/types/routing.d.ts
+type RoutePath = string;
+type RouteConfig = {
+  path: RoutePath;
+  component?: () => unknown;
+  loaders?: () => Promise<unknown>;
+  meta?: Record<string, unknown>;
+};
+//#endregion
+//#region src/router/vite-plugin/vite-plugin-options-advanced.d.ts
+interface SolidRouterPluginAdvancedOptions {
+  /**
+   * Enable caching
+   * @default true
+   */
+  caching?: boolean;
+  /**
+   * Caching configuration
+   */
+  cachingConfig?: {
+    /**
+     * Cache strategy
+     * @default "swr"
+     */
+    strategy?: "swr" | "stale-while-revalidate" | "network-first";
+    /**
+     * Max cache size
+     * @default 100
+     */
+    maxSize?: number;
+    /**
+     * Eviction policy
+     * @default "lru"
+     */
+    evictionPolicy?: "lru" | "fifo" | "lfu";
+    /**
+     * Default TTL (ms)
+     * @default 5000
+     */
+    defaultTtl?: number;
+  };
+  /**
+   * Enable predictive preloading
+   * @default false
+   */
+  predictivePreloading?: boolean;
+  /**
+   * Predictive preloading configuration
+   */
+  preloadingConfig?: {
+    /**
+     * Preload threshold (probability)
+     * @default 0.5
+     */
+    threshold?: number;
+    /**
+     * Max routes to preload
+     * @default 3
+     */
+    maxRoutes?: number;
+    /**
+     * History length for predictions
+     * @default 100
+     */
+    historyLength?: number;
+  };
+  /**
+   * Enable error tracking
+   * @default false
+   */
+  errorTracking?: boolean;
+  /**
+   * Error tracking configuration
+   */
+  errorTrackingConfig?: {
+    /**
+     * Error tracking endpoint
+     */
+    endpoint?: string;
+    /**
+     * Max errors to store
+     * @default 1000
+     */
+    maxErrors?: number;
+    /**
+     * Enable error aggregation
+     * @default true
+     */
+    aggregation?: boolean;
+  };
+  /**
+   * Custom routes
+   */
+  routes?: RouteConfig[];
+  /**
+   * Generate TypeScript types for routes
+   * @default true
+   */
+  generateTypes?: boolean;
+  /**
+   * Output directory for generated types
+   * @default "src/types"
+   */
+  typesOutputDir?: string;
+  /**
+   * Enable HMR for routes
+   * @default true
+   */
+  hmr?: boolean;
+  /**
+   * HMR configuration
+   */
+  hmrConfig?: {
+    /**
+     * Enable overlay
+     * @default true
+     */
+    overlay?: boolean;
+    /**
+     * HMR timeout (ms)
+     * @default 1000
+     */
+    timeout?: number;
+  };
+}
+//#endregion
+//#region src/router/vite-plugin/vite-plugin-options-features.d.ts
+interface SolidRouterPluginFeatureOptions {
+  /**
+   * Enable code splitting
+   * @default true
+   */
+  codeSplitting?: boolean;
+  /**
+   * Code splitting configuration
+   */
+  codeSplittingConfig?: {
+    /**
+     * Splitting strategy
+     * @default "auto"
+     */
+    strategy?: "auto" | "manual" | "aggressive";
+    /**
+     * Enable device-specific splitting
+     * @default false
+     */
+    deviceSpecific?: boolean;
+    /**
+     * Bundle size threshold for splitting (KB)
+     * @default 100
+     */
+    bundleSizeThreshold?: number;
+  };
+  /**
+   * Enable i18n support
+   * @default false
+   */
+  i18n?: boolean;
+  /**
+   * i18n configuration
+   */
+  i18nConfig?: {
+    /**
+     * Default locale
+     * @default "en"
+     */
+    defaultLocale?: string;
+    /**
+     * Supported locales
+     */
+    supportedLocales?: string[];
+    /**
+     * Locale detection methods
+     * @default ["path", "header"]
+     */
+    detection?: Array<"path" | "header" | "cookie" | "query">;
+    /**
+     * Directory containing locale files
+     * @default "src/locales"
+     */
+    localesDir?: string;
+  };
+  /**
+   * Enable feature flags
+   * @default false
+   */
+  featureFlags?: boolean;
+  /**
+   * Feature flags configuration
+   */
+  featureFlagsConfig?: {
+    /**
+     * API endpoint for feature flags
+     */
+    apiEndpoint?: string;
+    /**
+     * Enable local feature flags
+     * @default true
+     */
+    localFlags?: boolean;
+    /**
+     * Enable audit logging
+     * @default false
+     */
+    auditLogging?: boolean;
+  };
+  /**
+   * Enable security scanning
+   * @default false
+   */
+  securityScanning?: boolean;
+  /**
+   * Security scanning configuration
+   */
+  securityConfig?: {
+    /**
+     * Enable specific security rules
+     */
+    rules?: Array<"open-redirect" | "path-traversal" | "missing-auth" | "sensitive-data" | "parameter-injection">;
+    /**
+     * Severity threshold for reporting
+     * @default "medium"
+     */
+    severityThreshold?: "low" | "medium" | "high";
+    /**
+     * Auto-fix issues
+     * @default false
+     */
+    autoFix?: boolean;
+  };
+}
+//#endregion
+//#region src/router/vite-plugin/vite-plugin-options-routing.d.ts
+interface SolidRouterPluginRoutingOptions {
+  /**
+   * Directory containing route files
+   * @default "src/routes"
+   */
+  routesDir?: string;
+  /**
+   * File extensions to scan for routes
+   * @default [".tsx", ".ts", ".jsx", ".js"]
+   */
+  routeExtensions?: string[];
+  /**
+   * Enable auto-import of router components
+   * @default true
+   */
+  autoImport?: boolean;
+  /**
+   * Auto-import configuration
+   */
+  autoImportConfig?: {
+    /**
+     * Components to auto-import
+     */
+    components?: string[];
+    /**
+     * Composables to auto-import
+     */
+    composables?: string[];
+    /**
+     * Directories to scan for auto-imports
+     */
+    dirs?: string[];
+  };
+  /**
+   * Enable DevTools integration
+   * @default true in development
+   */
+  devTools?: boolean;
+  /**
+   * Enable performance monitoring
+   * @default false
+   */
+  performanceMonitoring?: boolean;
+  /**
+   * Performance monitoring configuration
+   */
+  performanceConfig?: {
+    /**
+     * Threshold for slow load time (ms)
+     * @default 1000
+     */
+    slowLoadThreshold?: number;
+    /**
+     * Threshold for slow render time (ms)
+     * @default 500
+     */
+    slowRenderThreshold?: number;
+    /**
+     * Enable performance alerts
+     * @default true
+     */
+    alerts?: boolean;
+  };
+}
+//#endregion
+//#region src/router/vite-plugin/vite-plugin-options.d.ts
+interface PluginLogger {
+  log: (message: string) => void;
+}
+interface SolidRouterPluginOptions extends SolidRouterPluginRoutingOptions, SolidRouterPluginFeatureOptions, SolidRouterPluginAdvancedOptions {
+  /**
+   * Optional logger for plugin messages. When omitted, plugin logs are silent.
+   */
+  logger?: PluginLogger;
+}
+//#endregion
+//#region src/vite/types/index.d.ts
+export interface SolidFrameworkPluginOptions {
+  /** Framework config (also emitted to virtual:solid-framework/config) */
+  config?: Partial<SolidFrameworkConfig>;
+  /** Router plugin options — pass false to disable route codegen plugin */
+  router?: SolidRouterPluginOptions | false;
+  /**
+   * Auto-import map: export name → module specifier.
+   * true = framework defaults; false = disabled; object = merged with defaults
+   */
+  autoImports?: Record<string, string | string[]> | boolean;
+  /** Serve SSR through the dev middleware — default true */
+  ssrMiddleware?: boolean;
+}
+export declare const VIRTUAL_CONFIG = "virtual:solid-framework/config";
+export declare const VIRTUAL_ROUTES = "virtual:solid-framework/routes";
+export declare const VIRTUAL_SERVER_FNS = "virtual:solid-framework/server-fns";
+//#endregion
+//#region src/vite/plugin.d.ts
+export declare const solidFramework: (options?: SolidFrameworkPluginOptions) => Plugin[];
+//#endregion
+//#region src/vite/prerender.d.ts
+/**
+ * Build-time Prerender
+ * Renders routes through the built server entry and writes static
+ * HTML to outDir — the SSG equivalent of Nitro's prerender, with
+ * crawlLinks discovering pages from rendered anchors
+ */
+/** Same-origin links found in rendered HTML — `href="/path"` */
+export declare const extractLinks: (html: string) => string[];
+export interface PrerenderResult {
+  path: string;
+  file: string;
+  status: number;
+}
+export declare const prerenderToDisk: (handler: (request: Request) => Promise<Response>, options: {
+  routes?: string[];
+  crawlLinks?: boolean;
+  outDir: string;
+  /** Base origin for constructed requests — default http://localhost */
+  base?: string;
+}) => Promise<PrerenderResult[]>;
+//#endregion
+//#region src/vite/server-fn-ids.d.ts
+/**
+ * Server Fn Id Transform
+ * Injects stable ids into `createServerFn({ ... })` calls that omit
+ * `id` — the hash derives from file path + call index so the client
+ * and server bundles agree without a runtime handshake
+ */
+export declare const injectServerFnIds: (code: string, fileId: string) => string;
+//#endregion
+//#region src/vite/virtual-modules.d.ts
+export declare const configModuleCode: (config: SolidFrameworkConfig, instrumentationPath?: string) => string;
+/**
+ * Route manifest — Vite glob import over the routes directory, plus a
+ * prebuilt RouteManifest for <FileRoutes>. Convention files
+ * (error/loading/not-found/layout) are included in the modules map.
+ */
+export declare const routesModuleCode: (routesDir: string) => string;
+/**
+ * Server function registry — eager glob of server modules so every
+ * createServerFn descriptor registers itself on the server bundle.
+ * Conventions:
+ *   *.server.ts  — server-only code (stubbed out of client bundles)
+ *   *.fn.ts      — isomorphic createServerFn definitions (client ships the
+ *                  remote caller only; handler executes server-side)
+ */
+export declare const serverFnsModuleCode: () => string;
+/**
+ * Stub emitted when a .server module leaks into the client bundle
+ */
+export declare const serverStubCode: (id: string) => string;
+export declare const isServerModuleId: (id: string) => boolean;
+//#endregion
+//# sourceMappingURL=vite.d.ts.map

package/dist/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","names":[],"sources":["../src/vite/auto-imports.ts","../src/render/types/index.ts","../src/app/types/index.ts","../src/vite/dev-middleware.ts","../src/router/shared/types/routing.ts","../src/router/vite-plugin/vite-plugin-options-advanced.ts","../src/router/vite-plugin/vite-plugin-options-features.ts","../src/router/vite-plugin/vite-plugin-options-routing.ts","../src/router/vite-plugin/vite-plugin-options.ts","../src/vite/types/index.ts","../src/vite/plugin.ts","../src/vite/prerender.ts","../src/vite/server-fn-ids.ts","../src/vite/virtual-modules.ts"],"mappings":"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"}