@craft-ts/core 0.7.0-beta.13 → 0.7.0-beta.15

package/src/lib/http-server.js

@@ -0,0 +1,590 @@
+export class HttpRequestError extends Error {
+    code;
+    status;
+    constructor(code, status, message) {
+        super(message);
+        this.name = 'HttpRequestError';
+        this.code = code;
+        this.status = status;
+    }
+}
+const MUTATION_METHODS = new Set([
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+]);
+export function createHttpServer(options) {
+    const routes = options.routes ?? [];
+    const middleware = [
+        // L'ordre est une décision de sécurité : les gardes d'entrée (hôte,
+        // origine, taille) passent avant la résolution d'identité, qui coûte
+        // souvent une vérification cryptographique ou un aller-retour réseau.
+        createRequestGuardMiddleware(options),
+        createIdentityMiddleware(options),
+        ...(options.middleware ?? []),
+    ];
+    const routeHandler = options.handler ?? createRouteHandler(routes);
+    const metrics = options.metrics ?? createHttpMetrics();
+    const maxConcurrent = options.maxConcurrentRequests ?? 0;
+    let inFlight = 0;
+    return {
+        metrics,
+        async handle(request) {
+            const startedAt = Date.now();
+            if (maxConcurrent > 0 && inFlight >= maxConcurrent) {
+                metrics.record({
+                    method: request.method,
+                    path: new URL(request.url).pathname,
+                    status: 503,
+                    durationMs: 0,
+                });
+                return withResponseHeaders(jsonError(503, 'HTTP_OVERLOADED', 'Server is at capacity.'), { 'retry-after': '1' });
+            }
+            inFlight += 1;
+            const requestId = requestIdFrom(request);
+            const timeout = timeoutSignal(request.signal, options.timeoutMs ?? 15_000);
+            const signal = timeout.signal;
+            const logger = options.logger ?? createJsonLogger(requestId, options.loggerSink);
+            const context = {
+                request,
+                requestId,
+                signal,
+                cspNonce: createCspNonce(),
+                params: {},
+                logger,
+            };
+            let response;
+            try {
+                response = await withAbort(composeServerMiddleware(middleware, () => routeHandler(request, context))(request, context), signal);
+            }
+            catch (error) {
+                response = errorResponse(error);
+                logger.error('http.request.failed', {
+                    method: request.method,
+                    path: new URL(request.url).pathname,
+                    durationMs: Date.now() - startedAt,
+                    error: publicErrorMessage(error),
+                });
+            }
+            inFlight -= 1;
+            timeout.dispose();
+            const responseWithHeaders = withResponseHeaders(response, {
+                'x-request-id': requestId,
+            });
+            logger.info('http.request.completed', {
+                method: request.method,
+                path: new URL(request.url).pathname,
+                status: response.status,
+                durationMs: Date.now() - startedAt,
+            });
+            metrics.record({
+                method: request.method,
+                path: new URL(request.url).pathname,
+                status: response.status,
+                durationMs: Date.now() - startedAt,
+            });
+            return responseWithHeaders;
+        },
+    };
+}
+export function createHttpMetrics() {
+    let requests = 0;
+    let errors = 0;
+    let totalDurationMs = 0;
+    let maxDurationMs = 0;
+    const statusCounts = {};
+    return {
+        record(entry) {
+            requests += 1;
+            if (entry.status >= 400)
+                errors += 1;
+            totalDurationMs += entry.durationMs;
+            maxDurationMs = Math.max(maxDurationMs, entry.durationMs);
+            const status = String(entry.status);
+            statusCounts[status] = (statusCounts[status] ?? 0) + 1;
+        },
+        snapshot() {
+            return {
+                requests,
+                errors,
+                totalDurationMs,
+                maxDurationMs,
+                statusCounts: { ...statusCounts },
+            };
+        },
+        reset() {
+            requests = 0;
+            errors = 0;
+            totalDurationMs = 0;
+            maxDurationMs = 0;
+            for (const status of Object.keys(statusCounts)) {
+                delete statusCounts[status];
+            }
+        },
+    };
+}
+export function createRateLimitMiddleware(options) {
+    if (!Number.isInteger(options.limit) || options.limit < 1) {
+        throw new RangeError('Rate-limit limit must be a positive integer.');
+    }
+    if (!Number.isInteger(options.windowMs) || options.windowMs < 1) {
+        throw new RangeError('Rate-limit windowMs must be a positive integer.');
+    }
+    const store = options.store ?? createInMemoryRateLimitStore();
+    const now = options.now ?? (() => Date.now());
+    const key = options.key;
+    return async (request, context, next) => {
+        if (options.skip?.(request))
+            return next();
+        const rateLimitKey = key(request, context);
+        const decision = store.consume(rateLimitKey, options.limit, options.windowMs, now());
+        const headers = rateLimitHeaders(decision);
+        if (!decision.allowed) {
+            context.logger.warn('http.rate_limit.rejected', {
+                key: rateLimitKey,
+                limit: decision.limit,
+                resetAt: decision.resetAt,
+            });
+            return withResponseHeaders(jsonError(429, 'HTTP_RATE_LIMITED', 'Too many requests.'), {
+                ...headers,
+                'retry-after': String(Math.max(1, Math.ceil((decision.resetAt - now()) / 1000))),
+            });
+        }
+        return withResponseHeaders(await next(), headers);
+    };
+}
+export function createInMemoryRateLimitStore() {
+    const buckets = new Map();
+    return {
+        consume(key, limit, windowMs, now) {
+            const current = buckets.get(key);
+            const bucket = current && current.resetAt > now
+                ? current
+                : { count: 0, resetAt: now + windowMs };
+            bucket.count += 1;
+            buckets.set(key, bucket);
+            if (buckets.size > 1024) {
+                for (const [bucketKey, candidate] of buckets) {
+                    if (candidate.resetAt <= now)
+                        buckets.delete(bucketKey);
+                }
+            }
+            return {
+                allowed: bucket.count <= limit,
+                limit,
+                remaining: Math.max(0, limit - bucket.count),
+                resetAt: bucket.resetAt,
+            };
+        },
+    };
+}
+export function composeServerMiddleware(middleware, terminal) {
+    return async (request, context) => {
+        const dispatch = (index) => {
+            if (index === middleware.length) {
+                return Promise.resolve(terminal(request, context));
+            }
+            return Promise.resolve(middleware[index](request, context, () => dispatch(index + 1)));
+        };
+        return dispatch(0);
+    };
+}
+export function matchServerRoute(request, routes) {
+    const method = request.method.toUpperCase();
+    const pathname = normalizePathname(new URL(request.url).pathname);
+    for (const route of routes) {
+        if (route.method !== method)
+            continue;
+        const params = matchPath(route.path, pathname);
+        if (params)
+            return { route, params };
+    }
+    return undefined;
+}
+export function createRequestGuardMiddleware(options) {
+    const maxBodyBytes = options.maxBodyBytes ?? 1_048_576;
+    const allowedOrigins = new Set(options.allowedOrigins ?? []);
+    const trustedHosts = new Set(options.trustedHosts ?? []);
+    return (request, context, next) => {
+        let url;
+        try {
+            url = new URL(request.url);
+        }
+        catch {
+            return jsonError(400, 'HTTP_REQUEST_INVALID', 'Invalid request URL.');
+        }
+        if (trustedHosts.size > 0 && !trustedHosts.has(url.host)) {
+            context.logger.warn('http.host.rejected', { host: url.host });
+            return jsonError(400, 'HTTP_HOST_NOT_ALLOWED', 'Host is not allowed.');
+        }
+        const contentLength = request.headers.get('content-length');
+        if (contentLength !== null) {
+            const length = Number(contentLength);
+            if (!Number.isSafeInteger(length) || length < 0) {
+                return jsonError(400, 'HTTP_CONTENT_LENGTH_INVALID', 'Invalid Content-Length.');
+            }
+            if (length > maxBodyBytes) {
+                return jsonError(413, 'HTTP_BODY_TOO_LARGE', 'Request body is too large.');
+            }
+        }
+        const origin = request.headers.get('origin');
+        const sameOrigin = origin === url.origin;
+        const allowed = origin !== null && (sameOrigin || allowedOrigins.has(origin));
+        // Une origine étrangère sur une méthode mutante est refusée par défaut :
+        // c'est le seul réglage qui protège une application montée sur cookie
+        // avant qu'elle n'ait configuré quoi que ce soit.
+        if (options.csrf !== 'off' &&
+            origin !== null &&
+            !allowed &&
+            MUTATION_METHODS.has(request.method.toUpperCase())) {
+            context.logger.warn('http.origin.rejected', {
+                method: request.method,
+                origin,
+            });
+            return jsonError(403, 'HTTP_ORIGIN_NOT_ALLOWED', 'Origin is not allowed.');
+        }
+        if (origin && !allowed && allowedOrigins.size > 0) {
+            return jsonError(403, 'HTTP_ORIGIN_NOT_ALLOWED', 'Origin is not allowed.');
+        }
+        if (allowed) {
+            return withCorsHeaders(request, next(), allowedOrigins, origin);
+        }
+        return next();
+    };
+}
+/**
+ * Résout l'identité et les services de la requête à l'intérieur du pipeline,
+ * pour qu'une session illisible produise une réponse d'erreur propre au lieu
+ * de rejeter la promesse du serveur.
+ */
+export function createIdentityMiddleware(options) {
+    return async (request, context, next) => {
+        const mutable = context;
+        if (options.user) {
+            const user = await options.user(request);
+            if (user !== undefined)
+                mutable.user = user;
+        }
+        if (options.services !== undefined) {
+            mutable.services =
+                typeof options.services === 'function'
+                    ? await options.services(request)
+                    : options.services;
+        }
+        return next();
+    };
+}
+export function createCorsMiddleware(allowedOrigins) {
+    const origins = new Set(allowedOrigins);
+    return (request, _context, next) => {
+        const origin = request.headers.get('origin');
+        if (request.method === 'OPTIONS') {
+            if (!origin || !origins.has(origin)) {
+                return jsonError(403, 'HTTP_ORIGIN_NOT_ALLOWED', 'Origin is not allowed.');
+            }
+            return new Response(null, {
+                status: 204,
+                headers: corsHeaders(origin),
+            });
+        }
+        const response = next();
+        return response.then((value) => origin && origins.has(origin)
+            ? withResponseHeaders(value, corsHeaders(origin))
+            : value);
+    };
+}
+export function createSecurityMiddleware(options = {}) {
+    const allowedOrigins = new Set(options.allowedOrigins ?? []);
+    const useNonce = options.useNonce ?? true;
+    return (request, context, next) => {
+        if (options.forceHttps) {
+            const url = new URL(request.url);
+            if (url.protocol === 'http:' && url.hostname !== 'localhost') {
+                url.protocol = 'https:';
+                return new Response(null, {
+                    status: 308,
+                    headers: { location: url.toString() },
+                });
+            }
+        }
+        const headers = {
+            'content-security-policy': contentSecurityPolicy(useNonce ? context.cspNonce : undefined, options.directives),
+            'x-content-type-options': 'nosniff',
+            'x-frame-options': 'SAMEORIGIN',
+            'referrer-policy': 'strict-origin-when-cross-origin',
+            'permissions-policy': 'camera=(), geolocation=(), microphone=()',
+            'cross-origin-opener-policy': 'same-origin',
+            'cross-origin-resource-policy': 'same-origin',
+        };
+        if (options.forceHttps) {
+            headers['strict-transport-security'] =
+                'max-age=31536000; includeSubDomains';
+        }
+        const origin = request.headers.get('origin');
+        if (origin && allowedOrigins.has(origin)) {
+            Object.assign(headers, corsHeaders(origin));
+        }
+        return next().then((response) => withResponseHeaders(response, headers));
+    };
+}
+/**
+ * Politique de base. Les domaines appartiennent au projet : `directives`
+ * ajoute des sources, la lib ne décide que du socle restrictif.
+ */
+export function contentSecurityPolicy(nonce, directives = {}) {
+    const base = {
+        'default-src': ["'self'"],
+        'base-uri': ["'self'"],
+        'object-src': ["'none'"],
+        'frame-ancestors': ["'self'"],
+        'form-action': ["'self'"],
+        'script-src': ["'self'", ...(nonce ? [`'nonce-${nonce}'`] : [])],
+        'style-src': [
+            "'self'",
+            // Repli documenté quand l'application n'a pas encore de nonce.
+            // craft-security-ignore CRAFT_SECURITY_CSP_UNSAFE_INLINE
+            ...(nonce ? [`'nonce-${nonce}'`] : ["'unsafe-inline'"]),
+        ],
+        'img-src': ["'self'", 'data:'],
+        'connect-src': ["'self'"],
+    };
+    for (const [directive, sources] of Object.entries(directives)) {
+        base[directive] = [...(base[directive] ?? []), ...sources];
+    }
+    return Object.entries(base)
+        .map(([directive, sources]) => `${directive} ${sources.join(' ')}`)
+        .join('; ');
+}
+/** Nonce par requête, au format base64 accepté par `provideCraftCspNonce`. */
+export function createCspNonce() {
+    const bytes = new Uint8Array(16);
+    if (globalThis.crypto?.getRandomValues) {
+        globalThis.crypto.getRandomValues(bytes);
+    }
+    else {
+        for (let index = 0; index < bytes.length; index += 1) {
+            bytes[index] = Math.floor(Math.random() * 256);
+        }
+    }
+    let binary = '';
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replace(/=+$/, '');
+}
+export function createCsrfMiddleware(options = {}) {
+    return async (request, context, next) => {
+        if (isSameSiteMutation(request, options.allowedOrigins))
+            return next();
+        context.logger.warn('http.csrf.rejected', { method: request.method });
+        return jsonError(403, 'HTTP_CSRF_REJECTED', 'CSRF validation failed.');
+    };
+}
+/**
+ * Une mutation est acceptée quand elle ne vient pas d'un autre site. Une
+ * origine absente est refusée sur une requête porteuse de cookie : c'est le
+ * cas d'un POST de formulaire cross-site, et un client légitime en envoie une.
+ */
+export function isSameSiteMutation(request, allowedOrigins = []) {
+    const method = request.method.toUpperCase();
+    if (!MUTATION_METHODS.has(method))
+        return true;
+    const site = request.headers.get('sec-fetch-site');
+    if (site)
+        return site === 'same-origin' || site === 'none';
+    const origin = request.headers.get('origin');
+    if (!origin)
+        return request.headers.get('cookie') === null;
+    let requestOrigin;
+    try {
+        requestOrigin = new URL(request.url).origin;
+    }
+    catch {
+        return false;
+    }
+    return origin === requestOrigin || allowedOrigins.includes(origin);
+}
+function createRouteHandler(routes) {
+    return async (request, context) => {
+        const match = matchServerRoute(request, routes);
+        if (!match) {
+            const pathname = normalizePathname(new URL(request.url).pathname);
+            const methods = routes
+                .filter((route) => matchPath(route.path, pathname))
+                .map((route) => route.method);
+            if (methods.length > 0) {
+                return new Response('Method Not Allowed', {
+                    status: 405,
+                    headers: { allow: [...new Set(methods)].join(', ') },
+                });
+            }
+            return jsonError(404, 'HTTP_ROUTE_NOT_FOUND', 'Route not found.');
+        }
+        if (match.route.auth === 'required' && context.user === undefined) {
+            return jsonError(401, 'HTTP_AUTH_REQUIRED', 'Authentication is required.');
+        }
+        if (match.route.csrf && !isSameSiteMutation(request)) {
+            context.logger.warn('http.csrf.rejected', {
+                method: request.method,
+                path: new URL(request.url).pathname,
+            });
+            return jsonError(403, 'HTTP_CSRF_REJECTED', 'CSRF validation failed.');
+        }
+        const routeContext = { ...context, params: match.params };
+        const response = await match.route.handler(request, routeContext);
+        return match.route.cache
+            ? withResponseHeaders(response, { 'cache-control': match.route.cache })
+            : response;
+    };
+}
+function decodeSegment(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        throw new HttpRequestError('HTTP_PATH_INVALID', 400, 'The request path is not valid percent-encoded UTF-8.');
+    }
+}
+function matchPath(template, pathname) {
+    const templateSegments = normalizePathname(template)
+        .split('/')
+        .filter(Boolean);
+    const pathSegments = pathname.split('/').filter(Boolean);
+    const params = {};
+    for (let index = 0; index < templateSegments.length; index += 1) {
+        const templateSegment = templateSegments[index];
+        const pathSegment = pathSegments[index];
+        if (templateSegment === '*') {
+            params['wildcard'] = pathSegments
+                .slice(index)
+                .map(decodeSegment)
+                .join('/');
+            return params;
+        }
+        if (pathSegment === undefined)
+            return undefined;
+        if (templateSegment.startsWith(':')) {
+            params[templateSegment.slice(1)] = decodeSegment(pathSegment);
+        }
+        else if (templateSegment !== decodeSegment(pathSegment)) {
+            return undefined;
+        }
+    }
+    return templateSegments.length === pathSegments.length ? params : undefined;
+}
+function normalizePathname(pathname) {
+    if (pathname === '/')
+        return '/';
+    return `/${pathname.split('/').filter(Boolean).join('/')}`;
+}
+function requestIdFrom(request) {
+    const candidate = request.headers.get('x-request-id');
+    if (candidate && /^[A-Za-z0-9._:-]{1,128}$/.test(candidate))
+        return candidate;
+    return (globalThis.crypto?.randomUUID?.() ?? `request-${Date.now().toString(36)}`);
+}
+/**
+ * Combine l'annulation du client et le délai maximal de la requête. Le repli
+ * manuel est important : sans lui, un runtime sans `AbortSignal.any` perdrait
+ * silencieusement tout timeout.
+ */
+function timeoutSignal(signal, timeoutMs) {
+    if (timeoutMs <= 0)
+        return { signal, dispose: () => undefined };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new DOMException('Request timed out', 'TimeoutError')), timeoutMs);
+    const forward = () => controller.abort(signal.reason);
+    if (signal.aborted)
+        forward();
+    else
+        signal.addEventListener('abort', forward, { once: true });
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', forward);
+        },
+    };
+}
+async function withAbort(response, signal) {
+    if (signal.aborted) {
+        throw new HttpRequestError('HTTP_REQUEST_TIMEOUT', 504, 'Request timed out.');
+    }
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(new HttpRequestError('HTTP_REQUEST_TIMEOUT', 504, 'Request timed out.'));
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+    try {
+        return await Promise.race([response, aborted]);
+    }
+    finally {
+        if (onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}
+function createJsonLogger(requestId, sink) {
+    const write = (level, event, data = {}) => {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            event,
+            requestId,
+            ...data,
+        };
+        if (sink)
+            sink(entry);
+        else
+            console.log(JSON.stringify(entry));
+    };
+    return {
+        debug: (event, data) => write('debug', event, data),
+        info: (event, data) => write('info', event, data),
+        warn: (event, data) => write('warn', event, data),
+        error: (event, data) => write('error', event, data),
+    };
+}
+function withCorsHeaders(request, response, allowedOrigins, directOrigin) {
+    const origin = directOrigin ?? request.headers.get('origin');
+    return Promise.resolve(response).then((value) => origin && allowedOrigins.has(origin)
+        ? withResponseHeaders(value, corsHeaders(origin))
+        : value);
+}
+function corsHeaders(origin) {
+    return {
+        'access-control-allow-origin': origin,
+        'access-control-allow-credentials': 'true',
+        'access-control-allow-methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+        'access-control-allow-headers': 'content-type, x-request-id, x-csrf-token',
+        vary: 'Origin',
+    };
+}
+function rateLimitHeaders(decision) {
+    return {
+        'x-ratelimit-limit': String(decision.limit),
+        'x-ratelimit-remaining': String(decision.remaining),
+        'x-ratelimit-reset': String(Math.ceil(decision.resetAt / 1000)),
+    };
+}
+function withResponseHeaders(response, headers) {
+    const merged = new Headers(response.headers);
+    for (const [name, value] of Object.entries(headers))
+        merged.set(name, value);
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: merged,
+    });
+}
+function jsonError(status, code, message) {
+    return Response.json({ error: { code, message } }, { status });
+}
+function errorResponse(error) {
+    if (error instanceof HttpRequestError) {
+        return jsonError(error.status, error.code, error.message);
+    }
+    return jsonError(500, 'HTTP_INTERNAL_ERROR', 'Internal Server Error.');
+}
+function publicErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/src/lib/insert-entities.d.ts

@@ -1,8 +1,8 @@
-import { InsertionStateFactoryContext } from './query.core';
-import { EntitiesUtilBrand, IdSelector } from './util/entities-util';
-import { AccessTypeObjectPropertyByDottedPath, DottedPathPathToTuple } from './util/types/access-type-object-property-by-dotted-path.type';
-import { ObjectDeepPath } from './util/types/object-deep-path-mapper.type';
-import { MergeObject, Prettify } from './util/util.type';
+import { InsertionStateFactoryContext } from './query.core.js';
+import { EntitiesUtilBrand, IdSelector } from './util/entities-util.js';
+import { AccessTypeObjectPropertyByDottedPath, DottedPathPathToTuple } from './util/types/access-type-object-property-by-dotted-path.type.js';
+import { ObjectDeepPath } from './util/types/object-deep-path-mapper.type.js';
+import { MergeObject, Prettify } from './util/util.type.js';
 type ArrayObjectDeepPath<State extends object> = ObjectDeepPath<State> extends infer Path ? Path extends string ? AccessTypeObjectPropertyByDottedPath<State, DottedPathPathToTuple<Path>> extends Array<any> ? Path : never : never : never;
 type DottedPathToCamel<Path extends string> = Path extends `${infer Head}.${infer Tail}` ? `${Head}${Capitalize<DottedPathToCamel<Tail>>}` : Path;
 type EntitiesUtilsToMap<EntityHelperFns, Entity, K, HasStateIdentifier, StateIdentifier, HasPath, Path, Acc = {}> = EntityHelperFns extends [infer First, ...infer Rest] ? First extends (data: infer Payload) => infer R ? R extends EntitiesUtilBrand<infer Name> ? EntitiesUtilsToMap<Rest, Entity, K, HasStateIdentifier, StateIdentifier, HasPath, Path, Acc & {
@@ -128,4 +128,3 @@ export declare function insertEntities<State, K extends string | number, Previou
     testHasPath: "path" extends keyof typeof config ? true : false;
 };
 export {};
-//# sourceMappingURL=insert-entities.d.ts.map

package/src/lib/insert-entities.js

@@ -1,4 +1,4 @@
-import { createNestedStateUpdate, getNestedStateValue, } from './util/update-state.util';
+import { createNestedStateUpdate, getNestedStateValue, } from './util/update-state.util.js';
 /**
  * Creates an insertion that adds entity collection management methods to state, query, or queryParams primitives.
  *
@@ -156,4 +156,3 @@ export function insertEntities(config) {
         return methods;
     };
 }
-//# sourceMappingURL=insert-entities.js.map

package/src/lib/insert-noop-typing-anchor.d.ts

@@ -1,4 +1,4 @@
-import type { InsertionStateFactoryContext } from './query.core';
+import type { InsertionStateFactoryContext } from './query.core.js';
 /**
  * No-op insertion used to preserve contextual typing in insertion chains of
  * the form-tree helpers (`insertForm` / `insertSelectFormTree`), which keep a
@@ -12,4 +12,3 @@ import type { InsertionStateFactoryContext } from './query.core';
  * which preserves nested contextual typing by itself.
  */
 export declare function insertNoopTypingAnchor<StateType, PreviousInsertionsOutputs = {}>(_context: InsertionStateFactoryContext<StateType, PreviousInsertionsOutputs>): {};
-//# sourceMappingURL=insert-noop-typing-anchor.d.ts.map

package/src/lib/insert-noop-typing-anchor.js

@@ -13,4 +13,3 @@
 export function insertNoopTypingAnchor(_context) {
     return {};
 }
-//# sourceMappingURL=insert-noop-typing-anchor.js.map

package/src/lib/insert-pagination-placeholder-data.d.ts

@@ -1,8 +1,8 @@
-import { Signal } from './host/craft-compat';
-import { type CraftSettledBrand } from './craft-settled';
-import { InsertionByIdParams, ResourceExceptionConstraints, YieldableInsertionWrite } from './query.core';
-import { CraftResourceStatus } from './util/craft-resource-status';
-import { type YieldableReactiveValue } from './reactive-read';
+import { Signal } from './host/craft-compat.js';
+import { type CraftSettledBrand } from './craft-settled.js';
+import { InsertionByIdParams, ResourceExceptionConstraints, YieldableInsertionWrite } from './query.core.js';
+import { CraftResourceStatus } from './util/craft-resource-status.js';
+import { type YieldableReactiveValue } from './reactive-read.js';
 /**
  * Base outputs produced by {@link insertPaginationPlaceholderData}.
  *
@@ -119,4 +119,3 @@ export declare function insertPaginationPlaceholderData<PageState, ExtraOutputs
     initialValue: PageState;
 }, build?: (context: PaginationBuildContext<PageState>) => ExtraOutputs): <GroupIdentifier extends string, ResourceParams, Exceptions extends ResourceExceptionConstraints, PreviousInsertionsOutputs, PrimitiveName extends string>(context: InsertionByIdParams<GroupIdentifier, PageState & object, ResourceParams, Exceptions, NoInfer<PreviousInsertionsOutputs>, PrimitiveName>) => PaginationBaseOutputs<PageState, PrimitiveName, Exceptions["params"] | Exceptions["loader"]> & ExtraOutputs;
 export {};
-//# sourceMappingURL=insert-pagination-placeholder-data.d.ts.map

package/src/lib/insert-pagination-placeholder-data.js

@@ -1,8 +1,8 @@
-import { craftComputed } from './craft-computed';
-import { isGenerator } from './craft-generator-runtime';
-import { settled } from './craft-settled';
-import { toCraftStatus, } from './util/craft-resource-status';
-import { createYieldableReactiveFacade, rawReactiveFacade, } from './reactive-read';
+import { craftComputed } from './craft-computed.js';
+import { isGenerator } from './craft-generator-runtime.js';
+import { settled } from './craft-settled.js';
+import { toCraftStatus, } from './util/craft-resource-status.js';
+import { createYieldableReactiveFacade, rawReactiveFacade, } from './reactive-read.js';
 function* readPaginationReactive(reader) {
     const value = reader();
     return isGenerator(value) ? yield* value : value;
@@ -241,4 +241,3 @@ export function insertPaginationPlaceholderData(config, build) {
         };
     };
 }
-//# sourceMappingURL=insert-pagination-placeholder-data.js.map