@flight-framework/core 0.0.3 → 0.2.0

package/dist/rsc/boundaries.d.ts

@@ -0,0 +1,182 @@
+/**
+ * @flight-framework/core - Component Boundary Detection
+ *
+ * Sistema de detección de boundaries client/server para Server Components.
+ * Soporta directivas 'use client' y 'use server' tanto a nivel de archivo
+ * como inline en funciones.
+ *
+ * Filosofía Flight:
+ * - Detección en build-time (no runtime overhead)
+ * - Soporte para directivas estándar de React
+ * - Extensible para otros frameworks
+ * - Zero dependencies
+ *
+ * @module @flight-framework/core/rsc/boundaries
+ */
+/**
+ * Tipo de boundary de componente
+ */
+type BoundaryType = 'server' | 'client' | 'shared';
+/**
+ * Información de un boundary detectado
+ */
+interface ComponentBoundary {
+    /** Tipo de boundary */
+    type: BoundaryType;
+    /** ID del módulo (path relativo o absoluto) */
+    moduleId: string;
+    /** Nombre del export */
+    exportName: string;
+    /** Línea donde se detectó la directiva */
+    line?: number;
+    /** Es una directiva inline (dentro de función) */
+    inline?: boolean;
+    /** Metadata adicional */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Resultado del análisis de un módulo
+ */
+interface ModuleAnalysis {
+    /** Path del módulo */
+    moduleId: string;
+    /** Directiva a nivel de archivo ('use client' o 'use server') */
+    fileDirective?: 'client' | 'server';
+    /** Boundaries detectados */
+    boundaries: ComponentBoundary[];
+    /** Exports que son Server Actions */
+    serverActions: string[];
+    /** Exports que son Client Components */
+    clientComponents: string[];
+    /** El módulo tiene componentes async */
+    hasAsyncComponents: boolean;
+}
+/**
+ * Referencia a un Client Component
+ */
+interface ClientReference<T = unknown> {
+    $$typeof: symbol;
+    $$id: string;
+    $$async: boolean;
+    __flight_client: true;
+    __flight_module: string;
+    __flight_export: string;
+    (props: T extends (props: infer P) => unknown ? P : unknown): unknown;
+}
+/**
+ * Referencia a una Server Function (Action)
+ */
+interface ServerReference<T extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown> {
+    $$typeof: symbol;
+    $$id: string;
+    $$bound: unknown[] | null;
+    __flight_server: true;
+    __flight_action: string;
+    (...args: Parameters<T>): Promise<ReturnType<T>>;
+}
+declare const CLIENT_REFERENCE: unique symbol;
+declare const SERVER_REFERENCE: unique symbol;
+/**
+ * Detecta si un archivo tiene la directiva 'use client'
+ */
+declare function hasUseClientDirective(source: string): boolean;
+/**
+ * Detecta si un archivo tiene la directiva 'use server' a nivel de archivo
+ */
+declare function hasUseServerDirective(source: string): boolean;
+/**
+ * Detecta el tipo de componente basado en directivas
+ */
+declare function detectBoundaryType(source: string): BoundaryType;
+/**
+ * Detecta Server Actions inline en el código
+ * Busca funciones que contienen 'use server' dentro de su cuerpo
+ */
+declare function detectInlineServerActions(source: string): string[];
+/**
+ * Detecta componentes async (Server Components potenciales)
+ */
+declare function detectAsyncComponents(source: string): string[];
+/**
+ * Análisis completo de un módulo
+ */
+declare function analyzeModule(source: string, moduleId: string): ModuleAnalysis;
+/**
+ * Crea una referencia a un Client Component
+ * Para uso en build-time (transformación de código)
+ */
+declare function createClientReference<T>(moduleId: string, exportName: string, isAsync?: boolean): ClientReference<T>;
+/**
+ * Crea una referencia a una Server Function (Action)
+ * Para uso en build-time (transformación de código)
+ */
+declare function createServerReference<T extends (...args: unknown[]) => unknown>(actionId: string, boundArgs?: unknown[]): ServerReference<T>;
+/**
+ * Verifica si un valor es una Client Reference
+ */
+declare function isClientReference(value: unknown): value is ClientReference;
+/**
+ * Verifica si un valor es una Server Reference
+ */
+declare function isServerReference(value: unknown): value is ServerReference;
+/**
+ * Obtiene el ID de una referencia
+ */
+declare function getReferenceId(ref: ClientReference | ServerReference): string;
+/**
+ * Registry de boundaries para uso en runtime
+ */
+declare class BoundaryRegistry {
+    private clientModules;
+    private serverActions;
+    /**
+     * Registra un Client Component
+     */
+    registerClient(id: string, loader: () => Promise<unknown>): void;
+    /**
+     * Registra una Server Action
+     */
+    registerServer(id: string, action: (...args: unknown[]) => Promise<unknown>): void;
+    /**
+     * Obtiene un Client Component loader
+     */
+    getClient(id: string): (() => Promise<unknown>) | undefined;
+    /**
+     * Obtiene una Server Action
+     */
+    getServer(id: string): ((...args: unknown[]) => Promise<unknown>) | undefined;
+    /**
+     * Verifica si un client module está registrado
+     */
+    hasClient(id: string): boolean;
+    /**
+     * Verifica si una server action está registrada
+     */
+    hasServer(id: string): boolean;
+    /**
+     * Obtiene todos los IDs de client modules
+     */
+    getClientIds(): string[];
+    /**
+     * Obtiene todos los IDs de server actions
+     */
+    getServerIds(): string[];
+    /**
+     * Limpia el registry
+     */
+    clear(): void;
+}
+/**
+ * Registry global (singleton)
+ */
+declare const globalRegistry: BoundaryRegistry;
+/**
+ * Registra un Client Component en el registry global
+ */
+declare function registerClientComponent(id: string, loader: () => Promise<unknown>): void;
+/**
+ * Registra una Server Action en el registry global
+ */
+declare function registerServerAction(id: string, action: (...args: unknown[]) => Promise<unknown>): void;
+
+export { BoundaryRegistry, type BoundaryType, CLIENT_REFERENCE, type ClientReference, type ComponentBoundary, type ModuleAnalysis, SERVER_REFERENCE, type ServerReference, analyzeModule, createClientReference, createServerReference, detectAsyncComponents, detectBoundaryType, detectInlineServerActions, getReferenceId, globalRegistry, hasUseClientDirective, hasUseServerDirective, isClientReference, isServerReference, registerClientComponent, registerServerAction };

package/dist/rsc/boundaries.js

@@ -0,0 +1,3 @@
+export { BoundaryRegistry, CLIENT_REFERENCE, SERVER_REFERENCE, analyzeModule, createClientReference, createServerReference, detectAsyncComponents, detectBoundaryType, detectInlineServerActions, getReferenceId, globalRegistry, hasUseClientDirective, hasUseServerDirective, isClientReference, isServerReference, registerClientComponent, registerServerAction } from '../chunk-CLZSB5QD.js';
+//# sourceMappingURL=boundaries.js.map
+//# sourceMappingURL=boundaries.js.map

package/dist/rsc/boundaries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"boundaries.js"}

package/dist/rsc/context.d.ts

@@ -0,0 +1,201 @@
+/**
+ * @flight-framework/core - Server Context
+ *
+ * API de contexto para Server Components.
+ * Provee acceso a datos del request de forma explícita y type-safe.
+ *
+ * Filosofía Flight:
+ * - Contexto EXPLÍCITO (no magia con AsyncLocalStorage)
+ * - Pasado como argumento (testeable, predecible)
+ * - Extensible con adapters custom
+ * - Inmutable por defecto
+ *
+ * @module @flight-framework/core/rsc/context
+ */
+/**
+ * Contexto del servidor disponible en Server Components
+ */
+interface ServerContext {
+    /** Request actual (Web API Request) */
+    readonly request: Request;
+    /** Parámetros de ruta */
+    readonly params: Readonly<Record<string, string>>;
+    /** Search params de la URL */
+    readonly searchParams: URLSearchParams;
+    /** Headers del request */
+    readonly headers: Headers;
+    /** Accessor de cookies */
+    readonly cookies: CookieAccessor;
+    /** Headers de respuesta (mutables) */
+    readonly responseHeaders: Headers;
+    /** Signal para cancelación */
+    readonly signal: AbortSignal;
+    /** URL parseada */
+    readonly url: URL;
+    /** Método HTTP */
+    readonly method: string;
+    /** Context extensions (para adapters) */
+    readonly extensions: ContextExtensions;
+}
+/**
+ * Accessor para cookies con lazy parsing
+ */
+interface CookieAccessor {
+    /** Obtiene el valor de una cookie */
+    get(name: string): string | undefined;
+    /** Obtiene todas las cookies */
+    getAll(): Readonly<Record<string, string>>;
+    /** Verifica si existe una cookie */
+    has(name: string): boolean;
+}
+/**
+ * Extensiones del contexto para adapters
+ */
+interface ContextExtensions {
+    /** Obtiene una extensión */
+    get<T>(key: string): T | undefined;
+    /** Verifica si existe una extensión */
+    has(key: string): boolean;
+}
+/**
+ * Opciones para crear ServerContext
+ */
+interface ServerContextOptions {
+    /** Parámetros de ruta */
+    params?: Record<string, string>;
+    /** Extensiones custom */
+    extensions?: Record<string, unknown>;
+    /** Headers de respuesta iniciales */
+    responseHeaders?: HeadersInit;
+}
+/**
+ * Crea un ServerContext a partir de un Request
+ *
+ * @example
+ * ```typescript
+ * const ctx = createServerContext(request, {
+ *   params: { id: '123' }
+ * });
+ *
+ * // En un Server Component
+ * async function UserPage(props, ctx: ServerContext) {
+ *   const userId = ctx.params.id;
+ *   const user = await db.users.get(userId);
+ *   return <UserProfile user={user} />;
+ * }
+ * ```
+ */
+declare function createServerContext(request: Request, options?: ServerContextOptions): ServerContext;
+/**
+ * Obtiene un header del request
+ */
+declare function getHeader(ctx: ServerContext, name: string): string | null;
+/**
+ * Obtiene todos los headers como objeto
+ */
+declare function getHeaders(ctx: ServerContext): Record<string, string>;
+/**
+ * Verifica si el request es un POST/PUT/PATCH/DELETE (mutation request)
+ */
+declare function isMutationRequest(ctx: ServerContext): boolean;
+/**
+ * Verifica si el request acepta JSON
+ */
+declare function acceptsJson(ctx: ServerContext): boolean;
+/**
+ * Verifica si el request es AJAX/fetch
+ */
+declare function isAjaxRequest(ctx: ServerContext): boolean;
+/**
+ * Verifica si el request viene de un bot
+ */
+declare function isBotRequest(ctx: ServerContext): boolean;
+/**
+ * Verifica si el cliente soporta streaming
+ */
+declare function supportsStreaming(ctx: ServerContext): boolean;
+/**
+ * Obtiene el idioma preferido del cliente
+ */
+declare function getPreferredLanguage(ctx: ServerContext, available: string[]): string | undefined;
+/**
+ * Sets a cookie in the response
+ */
+declare function setCookie(ctx: ServerContext, name: string, value: string, options?: CookieOptions): void;
+/**
+ * Deletes a cookie
+ */
+declare function deleteCookie(ctx: ServerContext, name: string, options?: Pick<CookieOptions, 'path' | 'domain'>): void;
+/**
+ * Cookie options
+ */
+interface CookieOptions {
+    /** Max age in seconds */
+    maxAge?: number;
+    /** Expiration date */
+    expires?: Date;
+    /** Cookie path */
+    path?: string;
+    /** Cookie domain */
+    domain?: string;
+    /** HTTPS only */
+    secure?: boolean;
+    /** Not accessible via JavaScript */
+    httpOnly?: boolean;
+    /** SameSite attribute */
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+/**
+ * Sets cache control headers
+ */
+declare function setCacheControl(ctx: ServerContext, options: CacheControlOptions): void;
+/**
+ * Cache control options
+ */
+interface CacheControlOptions {
+    public?: boolean;
+    private?: boolean;
+    noCache?: boolean;
+    noStore?: boolean;
+    maxAge?: number;
+    sMaxAge?: number;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+    mustRevalidate?: boolean;
+    immutable?: boolean;
+}
+/**
+ * Not found error - triggers 404 handling
+ */
+declare function notFound(message?: string): never;
+/**
+ * Check if error is a not found error
+ */
+declare function isNotFoundError(error: unknown): boolean;
+/**
+ * Redirect error - triggers redirect handling
+ */
+declare function redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): never;
+/**
+ * Check if error is a redirect error
+ */
+declare function isRedirectError(error: unknown): error is Error & {
+    __flight_redirect: {
+        url: string;
+        status: number;
+    };
+};
+/**
+ * Get redirect info from error
+ */
+declare function getRedirectInfo(error: Error & {
+    __flight_redirect: {
+        url: string;
+        status: number;
+    };
+}): {
+    url: string;
+    status: number;
+};
+
+export { type CacheControlOptions, type ContextExtensions, type CookieAccessor, type CookieOptions, type ServerContext, type ServerContextOptions, acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming };

package/dist/rsc/context.js

@@ -0,0 +1,3 @@
+export { acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming } from '../chunk-62C7LX2E.js';
+//# sourceMappingURL=context.js.map
+//# sourceMappingURL=context.js.map

package/dist/rsc/context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"context.js"}

package/dist/rsc/index.d.ts

@@ -1,131 +1,27 @@
+import { ServerContext } from './context.js';
+export { CacheControlOptions, ContextExtensions, CookieAccessor, CookieOptions, ServerContextOptions, acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming } from './context.js';
+import { FlightElement } from './payload.js';
+export { ClientReferenceChunk, ErrorBoundaryChunk, FlightChunk, FlightClientElement, FlightFragmentElement, FlightHostElement, FlightLazyElement, FlightNullElement, FlightPayloadError, FlightSerializationError, FlightSuspenseElement, FlightTextElement, HintChunk, MetaChunk, SerializedSpecialValue, SerializedValue, ServerComponentChunk, ServerReferenceChunk, SpecialValueType, clientRef, createActionChunk, createClientChunk, createErrorChunk, createHintChunk, createServerChunk, deserialize, fragment, generateChunkId, h, isFlightElement, resetChunkIdCounter, serialize, suspense, text, toFlightElement } from './payload.js';
+export { BoundaryRegistry, BoundaryType, CLIENT_REFERENCE, ClientReference, ComponentBoundary, ModuleAnalysis, SERVER_REFERENCE, ServerReference, analyzeModule, createClientReference, createServerReference, detectAsyncComponents, detectBoundaryType, detectInlineServerActions, getReferenceId, globalRegistry, hasUseClientDirective, hasUseServerDirective, isClientReference, isServerReference, registerClientComponent, registerServerAction } from './boundaries.js';
+export { FlightResponseOptions, FlightStreamError, FlightStreamOptions, FlightStreamResult, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream } from './stream.js';
+export { ComponentFn, ElementTypeInfo, FlightRenderer, RenderOptions, RenderResult, UIAdapter, createRenderer, renderServerComponent, renderServerComponentStreaming } from './renderer.js';
+export { ReactConsumerOptions, ReactServerComponent, createReactAdapter, createReactConsumer, markAsClientComponent } from './adapters/react.js';
+export { ClientManifestEntry, FlightRSCPluginOptions, ServerManifestEntry, default as flightRSC } from './vite-plugin.js';
+export { ComponentType, ClientComponent as LegacyClientComponent, ServerComponent as LegacyServerComponent, RenderContext, composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError as legacyIsNotFoundError, isRedirectError as legacyIsRedirectError, notFound as legacyNotFound, redirect as legacyRedirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary } from './legacy.js';
+import 'react';
+import 'vite';
+
 /**
- * @flight-framework/core - React Server Components Support
- *
- * Framework-agnostic primitives for RSC-like patterns.
- * Enables async server components, client/server boundaries, and data fetching.
- *
- * Best Practices 2025/2026:
- * - Async components for server-side data fetching
- * - 'use client' / 'use server' directive detection
- * - Automatic component serialization
- * - Props passing between server and client
- */
-/**
- * Component rendering context
- */
-interface RenderContext {
-    /** Current request */
-    request: Request;
-    /** Route params */
-    params: Record<string, string>;
-    /** Search params */
-    searchParams: URLSearchParams;
-    /** Request headers */
-    headers: Headers;
-    /** Cookies */
-    cookies: Map<string, string>;
-}
-/**
- * Server component definition
- */
-interface ServerComponent<P = unknown> {
-    (props: P, context: RenderContext): Promise<string> | string;
-    /** Mark as server component */
-    __flight_server?: true;
-    /** Dependencies for hydration */
-    __flight_deps?: string[];
-}
-/**
- * Client component definition
- */
-interface ClientComponent<P = unknown> {
-    (props: P): unknown;
-    /** Mark as client component */
-    __flight_client?: true;
-    /** Client bundle path */
-    __flight_bundle?: string;
-}
-/**
- * Component type detection
- */
-type ComponentType = 'server' | 'client' | 'hybrid';
-/**
- * Check if a file has 'use client' directive
- */
-declare function hasUseClientDirective(source: string): boolean;
-/**
- * Check if a file has 'use server' directive
- */
-declare function hasUseServerDirective(source: string): boolean;
-/**
- * Detect component type from source
- */
-declare function detectComponentType(source: string): ComponentType;
-/**
- * Execute an async server component
- */
-declare function executeServerComponent<P>(component: ServerComponent<P>, props: P, context: RenderContext): Promise<string>;
-/**
- * Create a render context from a Request
- */
-declare function createRenderContext(request: Request, params?: Record<string, string>): RenderContext;
-/**
- * Server-side fetch with automatic caching (like Next.js fetch extensions)
- */
-declare function serverFetch<T>(url: string, options?: RequestInit & {
-    revalidate?: number | false;
-    tags?: string[];
-}): Promise<T>;
-/**
- * Invalidate cache by tag
- */
-declare function revalidateTag(tag: string): void;
-/**
- * Invalidate cache by path
- */
-declare function revalidatePath(path: string): void;
-/**
- * Serialize props for transmission to client
- */
-declare function serializeProps(props: unknown): string;
-/**
- * Deserialize props on client
- */
-declare function deserializeProps<T>(serialized: string): T;
-/**
- * Create a client boundary placeholder
- */
-declare function createClientBoundary(componentId: string, props: unknown, fallback?: string): string;
-/**
- * Helper to create an async server component
- */
-declare function createAsyncComponent<P, T>(fetcher: (props: P, context: RenderContext) => Promise<T>, renderer: (data: T, props: P) => string): ServerComponent<P>;
-/**
- * Compose multiple server components
- */
-declare function composeComponents(...components: Array<() => Promise<string> | string>): () => Promise<string>;
-/**
- * Wrap a server component with error handling
- */
-declare function withErrorBoundary<P>(component: ServerComponent<P>, errorFallback: (error: Error) => string): ServerComponent<P>;
-/**
- * Throw a not found error (like Next.js notFound())
- */
-declare function notFound(): never;
-/**
- * Check if error is not found
+ * Server Component function type
  */
-declare function isNotFoundError(error: unknown): boolean;
+type ServerComponentFn<P = unknown, R = FlightElement> = (props: P, ctx: ServerContext) => R | Promise<R>;
 /**
- * Server-side redirect (like Next.js redirect())
+ * Server Action function type
  */
-declare function redirect(url: string, type?: 'replace' | 'push'): never;
+type ServerActionFn<Args extends unknown[] = unknown[], R = unknown> = (...args: Args) => Promise<R>;
 /**
- * Check if error is redirect
+ * Props for a component
  */
-declare function isRedirectError(error: unknown): {
-    url: string;
-    type: string;
-} | null;
+type ComponentProps<T> = T extends (props: infer P, ...args: unknown[]) => unknown ? P : never;
 
-export { type ClientComponent, type ComponentType, type RenderContext, type ServerComponent, composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, detectComponentType, executeServerComponent, hasUseClientDirective, hasUseServerDirective, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary };
+export { type ComponentProps, FlightElement, type ServerActionFn, type ServerComponentFn, ServerContext };

package/dist/rsc/index.js

@@ -1,3 +1,15 @@
-export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, detectComponentType, executeServerComponent, hasUseClientDirective, hasUseServerDirective, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary } from '../chunk-5KF3QQWZ.js';
+import '../chunk-63SCEXD7.js';
+export { FlightStreamError, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream } from '../chunk-T3S5YC7L.js';
+export { FlightRenderer, createRenderer, renderServerComponent, renderServerComponentStreaming } from '../chunk-4F77J5TY.js';
+export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError as legacyIsNotFoundError, isRedirectError as legacyIsRedirectError, notFound as legacyNotFound, redirect as legacyRedirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary } from '../chunk-3AY23FZP.js';
+export { flightRSC } from '../chunk-MRLCNFSD.js';
+import '../chunk-Y22AMGTM.js';
+import '../chunk-Q62ZQ6FM.js';
+export { createReactAdapter, createReactConsumer, markAsClientComponent } from '../chunk-PSJPMEQK.js';
+import '../chunk-BJIMTO2I.js';
+import '../chunk-6CD5FIYI.js';
+export { FlightPayloadError, FlightSerializationError, clientRef, createActionChunk, createClientChunk, createErrorChunk, createHintChunk, createServerChunk, deserialize, fragment, generateChunkId, h, isFlightElement, resetChunkIdCounter, serialize, suspense, text, toFlightElement } from '../chunk-K2CQZPCG.js';
+export { BoundaryRegistry, CLIENT_REFERENCE, SERVER_REFERENCE, analyzeModule, createClientReference, createServerReference, detectAsyncComponents, detectBoundaryType, detectInlineServerActions, getReferenceId, globalRegistry, hasUseClientDirective, hasUseServerDirective, isClientReference, isServerReference, registerClientComponent, registerServerAction } from '../chunk-CLZSB5QD.js';
+export { acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming } from '../chunk-62C7LX2E.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map