universal-api-layer 0.7.0

package/dist/angular/index.js

@@ -0,0 +1,142 @@
+import "../chunk-HDW7BOZI.js";
+import "../chunk-DXYWZQW5.js";
+import {
+  ApiError
+} from "../chunk-YTM3FV65.js";
+
+// src/angular/index.ts
+import {
+  DestroyRef,
+  InjectionToken,
+  inject,
+  makeEnvironmentProviders,
+  signal
+} from "@angular/core";
+import { Observable } from "rxjs";
+var API_CLIENT = new InjectionToken(
+  "universal-api-layer client"
+);
+function provideApiClient(value) {
+  return makeEnvironmentProviders([
+    {
+      provide: API_CLIENT,
+      ...typeof value === "function" ? { useFactory: value } : { useValue: value }
+    },
+    {
+      provide: ApiService,
+      useFactory: () => {
+        const service = new ApiService(injectApiClient());
+        inject(DestroyRef).onDestroy(() => service.dispose());
+        return service;
+      }
+    }
+  ]);
+}
+function injectApiClient() {
+  return inject(API_CLIENT);
+}
+function injectApiSession(client = injectApiClient()) {
+  const destroy = inject(DestroyRef);
+  const state = signal(client.getSessionSnapshot());
+  destroy.onDestroy(
+    client.subscribeSession(() => state.set(client.getSessionSnapshot()))
+  );
+  return state.asReadonly();
+}
+var ApiService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  lifetime = new AbortController();
+  /** Automatically called when the providing injector is destroyed. */
+  dispose() {
+    this.lifetime.abort(
+      new ApiError(
+        "Angular API provider destroyed",
+        0,
+        {},
+        void 0,
+        "cancelled"
+      )
+    );
+  }
+  operation(external, work) {
+    return new Observable((subscriber) => {
+      const revision = this.client.getSessionSnapshot().revision;
+      const controller = new AbortController();
+      const signals = [this.lifetime.signal, external].filter(
+        (value) => value !== void 0
+      );
+      const cleanups = signals.map((source) => {
+        const abort = () => controller.abort(source.reason);
+        if (source.aborted) abort();
+        else source.addEventListener("abort", abort, { once: true });
+        return () => source.removeEventListener("abort", abort);
+      });
+      void Promise.resolve().then(async () => {
+        if (subscriber.closed) return;
+        if (controller.signal.aborted)
+          throw new ApiError(
+            "Angular API operation cancelled",
+            0,
+            {},
+            void 0,
+            "cancelled",
+            controller.signal.reason
+          );
+        this.client.assertSession(revision);
+        await work(controller.signal, subscriber, revision);
+        this.client.assertSession(revision);
+        if (!subscriber.closed) subscriber.complete();
+      }).catch((error) => {
+        if (!subscriber.closed) subscriber.error(error);
+      });
+      return () => {
+        for (const cleanup of cleanups) cleanup();
+        controller.abort(
+          new ApiError(
+            "Angular API subscription cancelled",
+            0,
+            {},
+            void 0,
+            "cancelled"
+          )
+        );
+      };
+    });
+  }
+  request$(url, options = {}) {
+    return this.operation(
+      options.signal,
+      async (signal2, subscriber, revision) => {
+        const result = await this.client.request(url, { ...options, signal: signal2 });
+        this.client.assertSession(revision);
+        if (!subscriber.closed) subscriber.next(result);
+      }
+    );
+  }
+  stream$(url, options = {}) {
+    return this.operation(
+      options.signal,
+      async (signal2, subscriber, revision) => {
+        for await (const value of this.client.stream(url, {
+          ...options,
+          signal: signal2
+        })) {
+          if (subscriber.closed) break;
+          this.client.assertSession(revision);
+          subscriber.next(value);
+          if (subscriber.closed) break;
+        }
+      }
+    );
+  }
+};
+export {
+  API_CLIENT,
+  ApiService,
+  injectApiClient,
+  injectApiSession,
+  provideApiClient
+};

package/dist/chunk-DXYWZQW5.js

@@ -0,0 +1,92 @@
+import {
+  ApiError
+} from "./chunk-YTM3FV65.js";
+
+// src/core/callbacks.ts
+function abortable(operation, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return operation();
+    }).then(
+      (value) => {
+        signal.removeEventListener("abort", abort);
+        if (signal.aborted) reject(signal.reason);
+        else resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      }
+    );
+  });
+}
+function invokeCallback(callback) {
+  try {
+    return callback();
+  } catch (cause) {
+    throw new ApiError(
+      "API callback failed",
+      0,
+      {},
+      void 0,
+      "callback",
+      cause
+    );
+  }
+}
+async function invokeAsyncCallback(callback) {
+  try {
+    await callback();
+  } catch (cause) {
+    throw new ApiError(
+      "API callback failed",
+      0,
+      {},
+      void 0,
+      "callback",
+      cause
+    );
+  }
+}
+
+// src/core/validation.ts
+async function validateResponse(schema, value, status) {
+  try {
+    let output;
+    if (typeof schema === "function") output = await schema(value);
+    else if ("~standard" in schema) {
+      const result = await schema["~standard"].validate(value);
+      if (result.issues) throw result;
+      output = result.value;
+    } else if (schema.parseAsync) output = await schema.parseAsync(value);
+    else output = schema.parse(value);
+    if (output === void 0)
+      throw new Error(
+        "Response schemas must return a validated value; use null for empty responses"
+      );
+    return output;
+  } catch (cause) {
+    throw new ApiError(
+      "Response validation failed",
+      status,
+      {},
+      void 0,
+      "validation",
+      cause
+    );
+  }
+}
+
+export {
+  abortable,
+  invokeCallback,
+  invokeAsyncCallback,
+  validateResponse
+};