lanka 1.0.0

package/dist/gateway/index.d.ts

@@ -0,0 +1,258 @@
+import { T as TLankaExecuteOptions, I as IALankaGatewayConfig, a as ILankaRequest, b as TLankaQueryBuilder } from '../ALankaGateway-ExlRGT3D.js';
+export { A as ALankaGateway, c as TLankaQueryParams } from '../ALankaGateway-ExlRGT3D.js';
+import { T as TLankaErrorHandler } from '../TLankaErrorHandler-Yfqtdh1M.js';
+export { I as ILankaInFlightCounter, l as lankaHttpInFlight } from '../lankaHttpInFlight-Bk1eIuSx.js';
+export { I as ILankaRequestContext, T as TLankaRequestMiddleware } from '../lankaRequestMiddleware-DAC5kCb7.js';
+import '../lankaStandardValidator-CL-r-zEV.js';
+import '@standard-schema/spec';
+
+/**
+ * A gateway's protected surface, handed to whoever builds one by calling.
+ *
+ * The names match `ALankaGateway`'s protected members exactly, and that is the
+ * parity contract: a consumer who switches styles moves the same call from
+ * `this.endpoint(...)` to `endpoint(...)` and changes nothing else.
+ */
+interface ILankaGatewayContext<TOptions> {
+    /** The full URL for a path: base API, then this gateway's own base path. */
+    endpoint: (path?: string) => string;
+    /** Sends through this gateway's request, mock handler included. */
+    request: <TReturn = unknown>(path: string, options?: TLankaExecuteOptions<TOptions>, mockHandler?: () => Promise<TReturn>) => Promise<TReturn>;
+    /** Serialises query parameters the way this gateway was configured to. */
+    buildQueryParams: <T extends object>(params: T) => URLSearchParams;
+}
+
+/** What a gateway is built from, whichever style builds it. */
+interface ILankaGatewayConfig<TOptions, TMethods extends object> extends IALankaGatewayConfig<TOptions> {
+    /** The endpoints this gateway offers, written over its own surface. */
+    methods: (context: ILankaGatewayContext<TOptions>) => TMethods;
+}
+/**
+ * A gateway, without writing a class.
+ *
+ * The bridge below is the whole mechanism, and it lives here rather than on the
+ * base for two reasons. The language reads `protected` from inside a deriving
+ * class body and nowhere else, so a factory outside the hierarchy could only
+ * reach the public half — the wrong one. And a `toStyleContext` ON the base
+ * would put `TOptions` in a method's parameter position, making the class
+ * invariant in it: every `ALankaGateway<unknown>` the locator holds would stop
+ * accepting a gateway typed for `RequestInit`.
+ *
+ * One implementation: what comes back is an instance of `ALankaGateway`, so a
+ * behaviour fix reaches both styles at once.
+ */
+declare const createLankaGateway: <TOptions, TMethods extends object>(config: ILankaGatewayConfig<TOptions, TMethods>) => TMethods;
+
+/**
+ * How a gateway request goes on the wire.
+ *
+ * A subclass declares one method, `request()`, and does only its own work there:
+ * `LankaFetchJsonRequest` returns parsed JSON, `LankaFetchFormDataRequest`
+ * returns the whole response, a custom transport returns whatever it likes.
+ *
+ * Overriding `request()` customises the request flow, failure handling, mock
+ * substitution, response transformation and log interception.
+ */
+declare abstract class ALankaRequest<TOptions = RequestInit> implements ILankaRequest<TOptions> {
+    protected readonly errorHandler?: TLankaErrorHandler;
+    protected readonly useMock: boolean;
+    protected constructor(config: {
+        errorHandler?: TLankaErrorHandler;
+        useMock?: boolean;
+    });
+    /**
+     * Performs the request and returns its result — a response, JSON or a custom
+     * type.
+     *
+     * @param endpoint Full URL
+     * @param options Transport-specific options
+     * @param mockHandler Mock, when there is one
+     */
+    protected abstract request<TReturn = Response>(endpoint: string, options?: TOptions, mockHandler?: () => Promise<TReturn>): Promise<TReturn>;
+    /**
+     * The single point EVERY gateway request passes through.
+     *
+     * Hence the in-flight accounting here: intent prefetch stands down while
+     * anything else is on the wire. The `finally` matters more than the increment —
+     * a rejected request that never decremented would disable prefetching for the
+     * rest of the session.
+     */
+    execute<TReturn = Response>(endpoint: string, options?: TLankaExecuteOptions<TOptions>, mockHandler?: () => Promise<TReturn>): Promise<TReturn>;
+}
+
+/**
+ * Transport layer interface for Gateway.
+ * Allows to swap between different communication protocols (HTTP Fetch, gRPC, WebSocket, etc.)
+ */
+interface ILankaTransport<TOptions = RequestInit> {
+    /**
+     * Executes a request and returns a Response.
+     * @param resource - Request resource (URL or Request object)
+     * @param options - Request options specific to transport implementation
+     * @returns Promise resolving to Response
+     */
+    request(resource: RequestInfo, options?: TOptions): Promise<Response>;
+}
+
+interface ILankaTransportRequestConfig<TOptions> {
+    transport?: ILankaTransport<TOptions>;
+    errorHandler?: TLankaErrorHandler;
+    useMock?: boolean;
+}
+/**
+ * The shape every fetch-backed request has: mock, send, check, parse.
+ *
+ * The three concrete requests differ in exactly two places — which transport
+ * they default to, and how they turn a successful `Response` into a value. Both
+ * are parameters of this template, so a fourth kind is a subclass with one
+ * method rather than a fourth copy of the sequence.
+ */
+declare abstract class ALankaTransportRequest<TOptions = RequestInit> extends ALankaRequest<TOptions> {
+    protected readonly transport: ILankaTransport<TOptions>;
+    protected constructor(config: ILankaTransportRequestConfig<TOptions>, createDefaultTransport: () => ILankaTransport<TOptions>);
+    protected request<TReturn>(endpoint: string, options?: TOptions, mockHandler?: () => Promise<TReturn>): Promise<TReturn>;
+    /**
+     * Turns a successful response into the value the caller asked for.
+     *
+     * The one step that genuinely differs between request kinds.
+     */
+    protected abstract parse<TReturn>(response: Response): Promise<TReturn>;
+    /**
+     * Refuses an unsuccessful response, and never returns.
+     *
+     * `TLankaErrorHandler` is typed `Promise<never>` — a handler must throw. It is
+     * still CALLED and then followed by a throw, because a handler that breaks its
+     * contract and returns would otherwise hand `undefined` back as if the request
+     * had succeeded, and a non-value must never become a value.
+     */
+    protected refuse(response: Response): Promise<never>;
+}
+
+/**
+ * The raw request: hands the `Response` back untouched.
+ *
+ * The minimal, extensible case — a caller wanting headers, a stream or a blob
+ * reads them off the response itself.
+ */
+declare class LankaFetchRequest<TOptions = RequestInit> extends ALankaTransportRequest<TOptions> {
+    constructor(config?: ILankaTransportRequestConfig<TOptions>);
+    protected parse<TReturn>(response: Response): Promise<TReturn>;
+}
+
+/**
+ * The functional style of `LankaFetchRequest`: the raw `Response`, for a download or a stream.
+ *
+ * One line, and that is the point — the factory IS the class, so a behaviour
+ * cannot exist in one style and not the other.
+ */
+declare const createLankaFetchRequest: <TOptions = RequestInit>(config?: ILankaTransportRequestConfig<TOptions>) => LankaFetchRequest<TOptions>;
+
+/** The JSON request: parses the body, and refuses a body that is not JSON. */
+/**
+ * A request kind that answers a parsed JSON body — what most endpoints return.
+ *
+ * A gateway holds one, and is handed it rather than constructing it, which is
+ * what lets a test give the same gateway a transport that never leaves the
+ * process. `createLankaFetchJsonRequest()` builds the same class.
+ */
+declare class LankaFetchJsonRequest<TOptions = RequestInit> extends ALankaTransportRequest<TOptions> {
+    constructor(config?: ILankaTransportRequestConfig<TOptions>);
+    /**
+     * Parses the body, or names the failure.
+     *
+     * The content type is read for the ERROR MESSAGE only. Using it to choose
+     * between two parse paths, where the second answers `{}` for any non-empty
+     * body it cannot parse, fails silently: the caller's schema is the first thing
+     * to notice, and the caller's SCREEN is where it shows up.
+     *
+     * A measured case: a dev server whose `/api` fell through to the SPA fallback
+     * answered `200 text/html` with `index.html`. Turned into `{}`, the schema
+     * refused it and a person read a validator's issue list on the sign-in card. A
+     * body a JSON transport cannot parse is never a value — it is a misrouted
+     * request, and saying so names the actual failure.
+     */
+    protected parse<TReturn>(response: Response): Promise<TReturn>;
+}
+
+/**
+ * The functional style of `LankaFetchJsonRequest`: a JSON body, which is what most endpoints answer.
+ *
+ * One line, and that is the point — the factory IS the class, so a behaviour
+ * cannot exist in one style and not the other.
+ */
+declare const createLankaFetchJsonRequest: <TOptions = RequestInit>(config?: ILankaTransportRequestConfig<TOptions>) => LankaFetchJsonRequest<TOptions>;
+
+/**
+ * The multipart request: hands the `Response` back untouched.
+ *
+ * Differs from `LankaFetchRequest` only in its transport — the one that must NOT
+ * set `content-type`, because the browser writes it with the boundary and a
+ * hand-set header leaves the body unparseable to the server.
+ */
+declare class LankaFetchFormDataRequest<TOptions = RequestInit> extends ALankaTransportRequest<TOptions> {
+    constructor(config?: ILankaTransportRequestConfig<TOptions>);
+    protected parse<TReturn>(response: Response): Promise<TReturn>;
+}
+
+/**
+ * The functional style of `LankaFetchFormDataRequest`: a multipart body, for an upload.
+ *
+ * One line, and that is the point — the factory IS the class, so a behaviour
+ * cannot exist in one style and not the other.
+ */
+declare const createLankaFetchFormDataRequest: <TOptions = RequestInit>(config?: ILankaTransportRequestConfig<TOptions>) => LankaFetchFormDataRequest<TOptions>;
+
+/**
+ * HTTP Fetch transport implementation.
+ * Uses native fetch API without any project-specific decorators.
+ * For project-specific logic (auth, error handling, etc.), use `request` parameter
+ * in Gateway config or create a custom transport.
+ */
+declare class LankaFetchTransport implements ILankaTransport<RequestInit> {
+    request(resource: RequestInfo, options?: RequestInit): Promise<Response>;
+}
+
+/**
+ * HTTP Fetch JSON transport implementation.
+ * Uses native fetch API with JSON-specific headers.
+ * Automatically sets Content-Type to application/json for requests with body.
+ * For project-specific logic (auth, error handling, etc.), use `request` parameter
+ * in Gateway config or create a custom transport.
+ */
+declare class LankaFetchJsonTransport implements ILankaTransport<RequestInit> {
+    request(resource: RequestInfo, options?: RequestInit): Promise<Response>;
+}
+
+/**
+ * HTTP Fetch FormData transport implementation.
+ * Uses native fetch API optimized for FormData requests.
+ * Does not set Content-Type header (browser will set it automatically with boundary).
+ * For project-specific logic (auth, error handling, etc.), use `request` parameter
+ * in Gateway config or create a custom transport.
+ */
+declare class LankaFetchFormDataTransport implements ILankaTransport<RequestInit> {
+    request(resource: RequestInfo, options?: RequestInit): Promise<Response>;
+}
+
+/**
+ * The query string a gateway sends, from the object a method was called with.
+ *
+ * Arrays become `key[]` repeated, nested objects become `key[inner]`: the shape
+ * most JSON APIs read back without being told about it.
+ *
+ * Plain loops over `Object.keys` rather than `Object.entries` and `forEach`: this
+ * runs on every request that carries a filter, and the pair array `entries`
+ * builds — two allocations per key, thrown away immediately — is a cost with
+ * nothing to show for it.
+ */
+declare const buildLankaQueryParams: TLankaQueryBuilder;
+
+interface ILankaListQueryParams {
+    page: number;
+    limit: number;
+    sortField?: string | null;
+    sortOrder?: string | null;
+    filters?: Record<string, unknown>;
+}
+
+export { ALankaRequest, IALankaGatewayConfig, type ILankaGatewayConfig, type ILankaGatewayContext, type ILankaListQueryParams, ILankaRequest, type ILankaTransport, LankaFetchFormDataRequest, LankaFetchFormDataTransport, LankaFetchJsonRequest, LankaFetchJsonTransport, LankaFetchRequest, LankaFetchTransport, TLankaExecuteOptions, TLankaQueryBuilder, buildLankaQueryParams, createLankaFetchFormDataRequest, createLankaFetchJsonRequest, createLankaFetchRequest, createLankaGateway };

package/dist/gateway/index.js

@@ -0,0 +1,438 @@
+import {
+  composeLankaRequestMiddleware
+} from "../chunk-YR4MZXMU.js";
+import {
+  lankaHttpInFlight
+} from "../chunk-UJEC7H6K.js";
+import {
+  handleLankaApiError
+} from "../chunk-73IVH3C6.js";
+import "../chunk-J5LA3Q6D.js";
+import {
+  LankaError
+} from "../chunk-Q7QESSYF.js";
+import {
+  getLankaHost
+} from "../chunk-RKYKK6MN.js";
+import {
+  lankaLogger
+} from "../chunk-C2HP7CRD.js";
+import {
+  getLankaFlags
+} from "../chunk-D27MREPB.js";
+import {
+  getActiveRuntime
+} from "../chunk-BGVDPDX4.js";
+
+// src/gateway/request/_abstractions/lanka-request/ALankaRequest.ts
+function classifyTransportError(error, timedOut) {
+  if (LankaError.is(error)) return error;
+  const name = readErrorName(error);
+  const isAbort = name === "AbortError" || name === "TimeoutError";
+  if (isAbort) {
+    const timedOutHere = timedOut || name === "TimeoutError";
+    return new LankaError({
+      kind: timedOutHere ? "timeout" : "aborted",
+      message: timedOutHere ? getLankaHost().timeoutErrorMessage() : readErrorMessage(error),
+      cause: error
+    });
+  }
+  if (error instanceof TypeError) {
+    return new LankaError({
+      kind: "network",
+      message: getLankaHost().networkErrorMessage(),
+      issues: [error.message],
+      cause: error
+    });
+  }
+  return error;
+}
+function readErrorName(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const name = error.name;
+  return typeof name === "string" ? name : void 0;
+}
+function readErrorMessage(error) {
+  if (typeof error === "string") return error;
+  if (typeof error !== "object" || error === null) return "";
+  const message = error.message;
+  return typeof message === "string" ? message : "";
+}
+var ALankaRequest = class {
+  errorHandler;
+  useMock;
+  constructor(config) {
+    const flags = getLankaFlags();
+    this.errorHandler = config.errorHandler ?? handleLankaApiError;
+    this.useMock = config.useMock ?? flags.isMockMode ?? false;
+  }
+  /**
+   * The single point EVERY gateway request passes through.
+   *
+   * Hence the in-flight accounting here: intent prefetch stands down while
+   * anything else is on the wire. The `finally` matters more than the increment —
+   * a rejected request that never decremented would disable prefetching for the
+   * rest of the session.
+   */
+  async execute(endpoint, options, mockHandler) {
+    const runtime = getActiveRuntime();
+    const { signal, timeoutMs, ...rest } = options ?? {};
+    const fallbackDeadline = runtime?.requestTimeoutMs;
+    const passedOptions = options === void 0 ? void 0 : rest;
+    let lastTimedOut = false;
+    const perform = async (ctx) => {
+      const lifetime = createRequestLifetime(signal, ctx.timeoutMs ?? fallbackDeadline);
+      try {
+        return await this.request(
+          ctx.endpoint,
+          withSignal(ctx.options, lifetime.signal),
+          mockHandler
+        );
+      } catch (error) {
+        lastTimedOut = lifetime.timedOut();
+        throw classifyTransportError(error, lastTimedOut);
+      } finally {
+        lifetime.dispose();
+      }
+    };
+    const run = composeLankaRequestMiddleware(runtime?.requestMiddleware ?? [], perform);
+    lankaHttpInFlight.begin();
+    try {
+      return await run({
+        endpoint,
+        options: passedOptions,
+        attempt: 1,
+        timeoutMs
+      });
+    } catch (error) {
+      throw classifyTransportError(error, lastTimedOut);
+    } finally {
+      lankaHttpInFlight.end();
+    }
+  }
+};
+function createRequestLifetime(external, timeoutMs) {
+  if (!external && !timeoutMs) {
+    return { signal: void 0, timedOut: () => false, dispose: () => void 0 };
+  }
+  const controller = new AbortController();
+  let expired = false;
+  const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+    expired = true;
+    controller.abort(new DOMException("Request timed out", "TimeoutError"));
+  }, timeoutMs);
+  const onExternalAbort = () => {
+    controller.abort(external?.reason);
+  };
+  if (external) {
+    if (external.aborted) onExternalAbort();
+    else external.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    timedOut: () => expired,
+    dispose: () => {
+      if (timer !== void 0) clearTimeout(timer);
+      external?.removeEventListener("abort", onExternalAbort);
+    }
+  };
+}
+function withSignal(options, signal) {
+  if (signal === void 0) return options;
+  return { ...options ?? {}, signal };
+}
+
+// src/gateway/request/_abstractions/lanka-transport-request/ALankaTransportRequest.ts
+var ALankaTransportRequest = class extends ALankaRequest {
+  transport;
+  constructor(config, createDefaultTransport) {
+    const flags = getLankaFlags();
+    super({
+      errorHandler: config.errorHandler,
+      useMock: config.useMock ?? flags.isMockMode ?? false
+    });
+    this.transport = config.transport ?? createDefaultTransport();
+  }
+  async request(endpoint, options, mockHandler) {
+    if (this.useMock && mockHandler) {
+      return await mockHandler();
+    }
+    const response = await this.transport.request(endpoint, options);
+    if (!response.ok) return await this.refuse(response);
+    return await this.parse(response);
+  }
+  /**
+   * Refuses an unsuccessful response, and never returns.
+   *
+   * `TLankaErrorHandler` is typed `Promise<never>` — a handler must throw. It is
+   * still CALLED and then followed by a throw, because a handler that breaks its
+   * contract and returns would otherwise hand `undefined` back as if the request
+   * had succeeded, and a non-value must never become a value.
+   */
+  async refuse(response) {
+    if (this.errorHandler) {
+      await this.errorHandler(response);
+    }
+    throw new LankaError({
+      kind: "http",
+      message: getLankaHost().httpErrorMessage(response.status),
+      status: response.status
+    });
+  }
+};
+
+// src/gateway/transport/lanka-fetch-json-transport/LankaFetchJsonTransport.ts
+var LankaFetchJsonTransport = class {
+  async request(resource, options) {
+    if (options?.body && !(options.body instanceof FormData)) {
+      const headers = new Headers(options.headers);
+      let body = options.body;
+      if (typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob)) {
+        body = JSON.stringify(body);
+      }
+      headers.set("Content-Type", "application/json");
+      return await fetch(resource, {
+        ...options,
+        headers,
+        body
+      });
+    }
+    return await fetch(resource, options);
+  }
+};
+
+// src/gateway/request/lanka-fetch-json-request/LankaFetchJsonRequest.ts
+var LankaFetchJsonRequest = class extends ALankaTransportRequest {
+  constructor(config = {}) {
+    super(config, () => new LankaFetchJsonTransport());
+  }
+  /**
+   * Parses the body, or names the failure.
+   *
+   * The content type is read for the ERROR MESSAGE only. Using it to choose
+   * between two parse paths, where the second answers `{}` for any non-empty
+   * body it cannot parse, fails silently: the caller's schema is the first thing
+   * to notice, and the caller's SCREEN is where it shows up.
+   *
+   * A measured case: a dev server whose `/api` fell through to the SPA fallback
+   * answered `200 text/html` with `index.html`. Turned into `{}`, the schema
+   * refused it and a person read a validator's issue list on the sign-in card. A
+   * body a JSON transport cannot parse is never a value — it is a misrouted
+   * request, and saying so names the actual failure.
+   */
+  async parse(response) {
+    const contentType = response.headers.get("content-type");
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new LankaError({
+        kind: "schema",
+        message: `Failed to parse JSON response (content-type: ${contentType ?? "none"}): ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+};
+
+// src/gateway/_utils/build-lanka-query-params/buildLankaQueryParams.ts
+var buildLankaQueryParams = (input) => {
+  const params = new URLSearchParams();
+  const append = (key, value) => {
+    if (value == null) return;
+    if (Array.isArray(value)) {
+      const itemKey = `${key}[]`;
+      for (let index = 0; index < value.length; index += 1) append(itemKey, value[index]);
+      return;
+    }
+    if (typeof value === "object") {
+      const inner = value;
+      const innerKeys = Object.keys(inner);
+      for (let index = 0; index < innerKeys.length; index += 1) {
+        const innerKey = innerKeys[index];
+        append(`${key}[${innerKey}]`, inner[innerKey]);
+      }
+      return;
+    }
+    params.append(key, String(value));
+  };
+  const source = input;
+  const keys = Object.keys(source);
+  for (let index = 0; index < keys.length; index += 1) append(keys[index], source[keys[index]]);
+  return params;
+};
+
+// src/gateway/_abstractions/lanka-gateway/ALankaGateway.ts
+var ALankaGateway = class {
+  requestExecutor;
+  queryParamsHandler;
+  useMock;
+  basePath;
+  constructor(config) {
+    lankaLogger.printGatewayLog("Create gateway", this);
+    const flags = getLankaFlags();
+    this.useMock = config.useMock ?? flags.isMockMode ?? false;
+    this.requestExecutor = config.request ?? new LankaFetchJsonRequest();
+    this.basePath = config.basePath ?? "";
+    this.queryParamsHandler = config.queryParamsHandler ?? buildLankaQueryParams;
+  }
+  /**
+   * Resolves endpoint for request.
+   * - Absolute paths (starting with "/") are returned as-is
+   * - Relative paths are joined with basePath
+   * - Query-only strings like "?a=1" are attached to basePath
+   */
+  endpoint(path = "") {
+    if (isAbsoluteUrl(path)) return path;
+    return this.withApiBase(this.resolvePath(path));
+  }
+  /**
+   * Joins `basePath` and the method path.
+   */
+  resolvePath(path) {
+    if (!path) return this.basePath;
+    if (path.startsWith("/")) return path;
+    if (path.startsWith("?")) return `${this.basePath}${path}`;
+    const left = this.basePath.endsWith("/") ? this.basePath.slice(0, -1) : this.basePath;
+    const right = path.startsWith("/") ? path.slice(1) : path;
+    return `${left}/${right}`;
+  }
+  /**
+   * Prefixes the API base URL from the host contract.
+   *
+   * Here rather than in every consumer: otherwise each consumer knows the URL
+   * and the framework does not, and a realtime plugin would have to know a
+   * specific application's build.
+   *
+   * Declaring the field and not using it would be worse than not declaring it: a
+   * declaration nothing is built from is a second truth, free to diverge from
+   * the first.
+   *
+   * An absolute URL never reaches here — `endpoint()` filters it out before the
+   * join.
+   */
+  withApiBase(path) {
+    const base = withoutTrailingSlashes(getLankaHost().apiBaseUrl);
+    if (!base) return path;
+    if (!path) return base;
+    return path.startsWith("/") ? `${base}${path}` : `${base}/${path}`;
+  }
+  buildQueryParams(params) {
+    return this.queryParamsHandler(params);
+  }
+  async request(path, options, mockHandler) {
+    return this.requestExecutor.execute(this.endpoint(path), options, mockHandler);
+  }
+  /**
+   * Allows to replace request implementation at runtime (e.g. feature flags / tests).
+   * If you prefer static customization - override `request()` in a subclass.
+   */
+  setRequest(request) {
+    this.requestExecutor = request;
+  }
+  setQueryParamsHandler(handler) {
+    this.queryParamsHandler = handler;
+  }
+};
+function isAbsoluteUrl(path) {
+  if (!path.includes("://")) return false;
+  return /^[a-z][a-z\d+\-.]*:\/\//i.test(path);
+}
+var lastRawBase = null;
+var lastTrimmedBase = "";
+function withoutTrailingSlashes(base) {
+  if (base !== lastRawBase) {
+    lastRawBase = base;
+    lastTrimmedBase = base.replace(/\/+$/, "");
+  }
+  return lastTrimmedBase;
+}
+
+// src/gateway/_factories/create-lanka-gateway/createLankaGateway.ts
+var createLankaGateway = (config) => {
+  class FunctionalGateway extends ALankaGateway {
+    // The base keeps a protected constructor — it is abstract, and a consumer
+    // reaching for `new ALankaGateway()` would get an object with no endpoints.
+    // A subclass may widen it, and this one is the subclass.
+    constructor(gatewayConfig) {
+      super(gatewayConfig);
+    }
+    build() {
+      return config.methods({
+        endpoint: (path) => this.endpoint(path),
+        request: (path, options, mockHandler) => this.request(path, options, mockHandler),
+        buildQueryParams: (params) => this.buildQueryParams(params)
+      });
+    }
+  }
+  return new FunctionalGateway(config).build();
+};
+
+// src/gateway/transport/lanka-fetch-transport/LankaFetchTransport.ts
+var LankaFetchTransport = class {
+  async request(resource, options) {
+    return await fetch(resource, options);
+  }
+};
+
+// src/gateway/request/lanka-fetch-request/LankaFetchRequest.ts
+var LankaFetchRequest = class extends ALankaTransportRequest {
+  constructor(config = {}) {
+    super(config, () => new LankaFetchTransport());
+  }
+  parse(response) {
+    return Promise.resolve(response);
+  }
+};
+
+// src/gateway/request/_factories/create-lanka-fetch-request/createLankaFetchRequest.ts
+var createLankaFetchRequest = (config = {}) => new LankaFetchRequest(config);
+
+// src/gateway/request/_factories/create-lanka-fetch-json-request/createLankaFetchJsonRequest.ts
+var createLankaFetchJsonRequest = (config = {}) => new LankaFetchJsonRequest(config);
+
+// src/gateway/transport/lanka-fetch-form-data-transport/LankaFetchFormDataTransport.ts
+var LankaFetchFormDataTransport = class {
+  async request(resource, options) {
+    const formDataOptions = { ...options };
+    if (formDataOptions.body instanceof FormData && formDataOptions.headers) {
+      const headers = new Headers(formDataOptions.headers);
+      headers.delete("Content-Type");
+      formDataOptions.headers = headers;
+    }
+    return await fetch(resource, formDataOptions);
+  }
+};
+
+// src/gateway/request/lanka-fetch-form-data-request/LankaFetchFormDataRequest.ts
+var LankaFetchFormDataRequest = class extends ALankaTransportRequest {
+  constructor(config = {}) {
+    super(config, () => new LankaFetchFormDataTransport());
+  }
+  parse(response) {
+    return Promise.resolve(response);
+  }
+};
+
+// src/gateway/request/_factories/create-lanka-fetch-form-data-request/createLankaFetchFormDataRequest.ts
+var createLankaFetchFormDataRequest = (config = {}) => new LankaFetchFormDataRequest(config);
+export {
+  ALankaGateway,
+  ALankaRequest,
+  LankaFetchFormDataRequest,
+  LankaFetchFormDataTransport,
+  LankaFetchJsonRequest,
+  LankaFetchJsonTransport,
+  LankaFetchRequest,
+  LankaFetchTransport,
+  buildLankaQueryParams,
+  createLankaFetchFormDataRequest,
+  createLankaFetchJsonRequest,
+  createLankaFetchRequest,
+  createLankaGateway,
+  lankaHttpInFlight
+};
+//# sourceMappingURL=index.js.map