cloesce 0.0.5-unstable.2 → 0.0.5-unstable.3

package/dist/ui/common.d.ts

@@ -1,7 +1,11 @@
 import { MediaType } from "../ast.js";
-type DeepPartialInner<T> = T extends (infer U)[] ? DeepPartialInner<U>[] : T extends object ? {
-    [K in keyof T]?: DeepPartialInner<T[K]>;
-} : T | (null extends T ? null : never);
+type DeepPartialInner<T> = T extends (infer U)[]
+  ? DeepPartialInner<U>[]
+  : T extends object
+    ? {
+        [K in keyof T]?: DeepPartialInner<T[K]>;
+      }
+    : T | (null extends T ? null : never);
 /**
  * Recursively makes all properties of a type optional — including nested objects and arrays.
  *
@@ -46,27 +50,30 @@ type DeepPartialInner<T> = T extends (infer U)[] ? DeepPartialInner<U>[] : T ext
  * ```
  */
 export type DeepPartial<T> = DeepPartialInner<T> & {
-    __brand?: "Partial";
+  __brand?: "Partial";
 };
 export declare class Either<L, R> {
-    private readonly inner;
-    private constructor();
-    get value(): L | R;
-    static left<R>(): Either<void, R>;
-    static left<L, R = never>(value: L): Either<L, R>;
-    static right<R, L = never>(value: R): Either<L, R>;
-    isLeft(): this is Either<L, never>;
-    isRight(): this is Either<never, R>;
-    unwrap(): R;
-    unwrapLeft(): L;
-    map<B>(fn: (val: R) => B): Either<L, B>;
-    mapLeft<B>(fn: (val: L) => B): Either<B, R>;
+  private readonly inner;
+  private constructor();
+  get value(): L | R;
+  static left<R>(): Either<void, R>;
+  static left<L, R = never>(value: L): Either<L, R>;
+  static right<R, L = never>(value: R): Either<L, R>;
+  isLeft(): this is Either<L, never>;
+  isRight(): this is Either<never, R>;
+  unwrap(): R;
+  unwrapLeft(): L;
+  map<B>(fn: (val: R) => B): Either<L, B>;
+  mapLeft<B>(fn: (val: L) => B): Either<B, R>;
 }
 /**
  * Given a media type and some data, converts to a proper
  * `RequestInit` body,
  */
-export declare function requestBody(mediaType: MediaType, data: any | string | undefined): undefined | string | FormData;
+export declare function requestBody(
+  mediaType: MediaType,
+  data: any | string | undefined,
+): undefined | string | FormData;
 /**
  * The result of a Workers endpoint.
  *
@@ -80,24 +87,40 @@ export declare function requestBody(mediaType: MediaType, data: any | string | u
  *
  */
 export declare class HttpResult<T = unknown> {
-    ok: boolean;
-    status: number;
-    headers: Headers;
-    data?: T | undefined;
-    message?: string | undefined;
-    mediaType?: MediaType | undefined;
-    constructor(ok: boolean, status: number, headers: Headers, data?: T | undefined, message?: string | undefined, mediaType?: MediaType | undefined);
-    static ok<T>(status: number, data?: T, init?: HeadersInit): HttpResult;
-    static fail(status: number, message?: string, init?: HeadersInit): HttpResult<never>;
-    toResponse(): Response;
-    setMediaType(mediaType: MediaType): this;
-    static fromResponse(response: Response, mediaType: MediaType, ctor?: any, array?: boolean): Promise<HttpResult<any>>;
+  ok: boolean;
+  status: number;
+  headers: Headers;
+  data?: T | undefined;
+  message?: string | undefined;
+  mediaType?: MediaType | undefined;
+  constructor(
+    ok: boolean,
+    status: number,
+    headers: Headers,
+    data?: T | undefined,
+    message?: string | undefined,
+    mediaType?: MediaType | undefined,
+  );
+  static ok<T>(status: number, data?: T, init?: HeadersInit): HttpResult;
+  static fail(
+    status: number,
+    message?: string,
+    init?: HeadersInit,
+  ): HttpResult<never>;
+  toResponse(): Response;
+  setMediaType(mediaType: MediaType): this;
+  static fromResponse(
+    response: Response,
+    mediaType: MediaType,
+    ctor?: any,
+    array?: boolean,
+  ): Promise<HttpResult<any>>;
 }
 export type Stream = ReadableStream<Uint8Array>;
 export declare function b64ToU8(b64: string): Uint8Array;
 export declare function u8ToB64(u8: Uint8Array): string;
 export type KeysOfType<T, U> = {
-    [K in keyof T]: T[K] extends U ? (K extends string ? K : never) : never;
+  [K in keyof T]: T[K] extends U ? (K extends string ? K : never) : never;
 }[keyof T];
 export {};
-//# sourceMappingURL=common.d.ts.map
+//# sourceMappingURL=common.d.ts.map

package/dist/ui/common.js

@@ -1,62 +1,64 @@
 import { MediaType } from "../ast.js";
 export class Either {
-    inner;
-    constructor(inner) {
-        this.inner = inner;
-    }
-    get value() {
-        return this.inner.ok ? this.inner.right : this.inner.left;
-    }
-    static left(value) {
-        return new Either({ ok: false, left: value });
-    }
-    static right(value) {
-        return new Either({ ok: true, right: value });
-    }
-    isLeft() {
-        return !this.inner.ok;
-    }
-    isRight() {
-        return this.inner.ok;
-    }
-    unwrap() {
-        if (!this.inner.ok) {
-            throw new Error("Tried to unwrap a Left value");
-        }
-        return this.inner.right;
-    }
-    unwrapLeft() {
-        if (this.inner.ok) {
-            throw new Error("Tried to unwrapLeft a Right value");
-        }
-        return this.inner.left;
-    }
-    map(fn) {
-        return this.inner.ok
-            ? Either.right(fn(this.inner.right))
-            : Either.left(this.inner.left);
-    }
-    mapLeft(fn) {
-        return this.inner.ok
-            ? Either.right(this.inner.right)
-            : Either.left(fn(this.inner.left));
-    }
+  inner;
+  constructor(inner) {
+    this.inner = inner;
+  }
+  get value() {
+    return this.inner.ok ? this.inner.right : this.inner.left;
+  }
+  static left(value) {
+    return new Either({ ok: false, left: value });
+  }
+  static right(value) {
+    return new Either({ ok: true, right: value });
+  }
+  isLeft() {
+    return !this.inner.ok;
+  }
+  isRight() {
+    return this.inner.ok;
+  }
+  unwrap() {
+    if (!this.inner.ok) {
+      throw new Error("Tried to unwrap a Left value");
+    }
+    return this.inner.right;
+  }
+  unwrapLeft() {
+    if (this.inner.ok) {
+      throw new Error("Tried to unwrapLeft a Right value");
+    }
+    return this.inner.left;
+  }
+  map(fn) {
+    return this.inner.ok
+      ? Either.right(fn(this.inner.right))
+      : Either.left(this.inner.left);
+  }
+  mapLeft(fn) {
+    return this.inner.ok
+      ? Either.right(this.inner.right)
+      : Either.left(fn(this.inner.left));
+  }
 }
 /**
  * Given a media type and some data, converts to a proper
  * `RequestInit` body,
  */
 export function requestBody(mediaType, data) {
-    switch (mediaType) {
-        case MediaType.Json: {
-            return JSON.stringify(data ?? {}, (_, v) => v instanceof Uint8Array ? u8ToB64(v) : v);
-        }
-        case MediaType.Octet: {
-            // JSON structure isn't needed; assume the first
-            // value is the stream data
-            return Object.values(data)[0];
-        }
-    }
+  switch (mediaType) {
+    case MediaType.Json: {
+      return JSON.stringify(data ?? {}, (_, v) =>
+        v instanceof Uint8Array ? u8ToB64(v) : v,
+      );
+    }
+    case MediaType.Octet: {
+      // JSON structure isn't needed; assume the first
+      // value is the stream data
+      return Object.values(data)[0];
+    }
+  }
 }
 /**
  * The result of a Workers endpoint.
@@ -71,121 +73,131 @@ export function requestBody(mediaType, data) {
  *
  */
 export class HttpResult {
-    ok;
-    status;
-    headers;
-    data;
-    message;
-    mediaType;
-    constructor(ok, status, headers, data, message, mediaType) {
-        this.ok = ok;
-        this.status = status;
-        this.headers = headers;
-        this.data = data;
-        this.message = message;
-        this.mediaType = mediaType;
-    }
-    static ok(status, data, init) {
-        const headers = new Headers(init);
-        return new HttpResult(true, status, headers, data, undefined);
-    }
-    static fail(status, message, init) {
-        const headers = new Headers(init);
-        return new HttpResult(false, status, headers, undefined, message);
-    }
-    toResponse() {
-        switch (this.mediaType) {
-            case MediaType.Json: {
-                this.headers.set("Content-Type", "application/json");
-                break;
-            }
-            case MediaType.Octet: {
-                this.headers.set("Content-Type", "application/octet-stream");
-                break;
-            }
-            case undefined: {
-                // Errors are always text.
-                this.headers.set("Content-Type", "text/plain");
-                return new Response(this.message, {
-                    status: this.status,
-                    headers: this.headers,
-                });
-            }
-        }
-        return new Response(requestBody(this.mediaType, this.data), {
-            status: this.status,
-            headers: this.headers,
+  ok;
+  status;
+  headers;
+  data;
+  message;
+  mediaType;
+  constructor(ok, status, headers, data, message, mediaType) {
+    this.ok = ok;
+    this.status = status;
+    this.headers = headers;
+    this.data = data;
+    this.message = message;
+    this.mediaType = mediaType;
+  }
+  static ok(status, data, init) {
+    const headers = new Headers(init);
+    return new HttpResult(true, status, headers, data, undefined);
+  }
+  static fail(status, message, init) {
+    const headers = new Headers(init);
+    return new HttpResult(false, status, headers, undefined, message);
+  }
+  toResponse() {
+    switch (this.mediaType) {
+      case MediaType.Json: {
+        this.headers.set("Content-Type", "application/json");
+        break;
+      }
+      case MediaType.Octet: {
+        this.headers.set("Content-Type", "application/octet-stream");
+        break;
+      }
+      case undefined: {
+        // Errors are always text.
+        this.headers.set("Content-Type", "text/plain");
+        return new Response(this.message, {
+          status: this.status,
+          headers: this.headers,
         });
-    }
-    setMediaType(mediaType) {
-        this.mediaType = mediaType;
-        return this;
-    }
-    static async fromResponse(response, mediaType, ctor, array = false) {
-        if (response.status >= 400) {
-            return new HttpResult(false, response.status, response.headers, undefined, await response.text());
+      }
+    }
+    return new Response(requestBody(this.mediaType, this.data), {
+      status: this.status,
+      headers: this.headers,
+    });
+  }
+  setMediaType(mediaType) {
+    this.mediaType = mediaType;
+    return this;
+  }
+  static async fromResponse(response, mediaType, ctor, array = false) {
+    if (response.status >= 400) {
+      return new HttpResult(
+        false,
+        response.status,
+        response.headers,
+        undefined,
+        await response.text(),
+      );
+    }
+    function instantiate(json, ctor) {
+      switch (ctor) {
+        case Date: {
+          return new Date(json);
         }
-        function instantiate(json, ctor) {
-            switch (ctor) {
-                case Date: {
-                    return new Date(json);
-                }
-                case Uint8Array: {
-                    return b64ToU8(json);
-                }
-                case undefined: {
-                    return json;
-                }
-                default: {
-                    return ctor.fromJson(json);
-                }
-            }
+        case Uint8Array: {
+          return b64ToU8(json);
         }
-        async function data() {
-            switch (mediaType) {
-                case MediaType.Json: {
-                    let json = await response.json();
-                    if (array) {
-                        for (let i = 0; i < json.length; i++) {
-                            json[i] = instantiate(json[i], ctor);
-                        }
-                    }
-                    else {
-                        json = instantiate(json, ctor);
-                    }
-                    return json;
-                }
-                case MediaType.Octet: {
-                    return response.body;
-                }
-            }
+        case undefined: {
+          return json;
+        }
+        default: {
+          return ctor.fromJson(json);
         }
-        return new HttpResult(true, response.status, response.headers, await data());
+      }
     }
+    async function data() {
+      switch (mediaType) {
+        case MediaType.Json: {
+          let json = await response.json();
+          if (array) {
+            for (let i = 0; i < json.length; i++) {
+              json[i] = instantiate(json[i], ctor);
+            }
+          } else {
+            json = instantiate(json, ctor);
+          }
+          return json;
+        }
+        case MediaType.Octet: {
+          return response.body;
+        }
+      }
+    }
+    return new HttpResult(
+      true,
+      response.status,
+      response.headers,
+      await data(),
+    );
+  }
 }
 export function b64ToU8(b64) {
-    // Prefer Buffer in Node.js environments
-    if (typeof Buffer !== "undefined") {
-        const buffer = Buffer.from(b64, "base64");
-        return new Uint8Array(buffer);
-    }
-    // Use atob only in browser environments
-    const s = atob(b64);
-    const u8 = new Uint8Array(s.length);
-    for (let i = 0; i < s.length; i++) {
-        u8[i] = s.charCodeAt(i);
-    }
-    return u8;
+  // Prefer Buffer in Node.js environments
+  if (typeof Buffer !== "undefined") {
+    const buffer = Buffer.from(b64, "base64");
+    return new Uint8Array(buffer);
+  }
+  // Use atob only in browser environments
+  const s = atob(b64);
+  const u8 = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) {
+    u8[i] = s.charCodeAt(i);
+  }
+  return u8;
 }
 export function u8ToB64(u8) {
-    // Prefer Buffer in Node.js environments
-    if (typeof Buffer !== "undefined") {
-        return Buffer.from(u8).toString("base64");
-    }
-    // Use btoa only in browser environments
-    let s = "";
-    for (let i = 0; i < u8.length; i++) {
-        s += String.fromCharCode(u8[i]);
-    }
-    return btoa(s);
+  // Prefer Buffer in Node.js environments
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(u8).toString("base64");
+  }
+  // Use btoa only in browser environments
+  let s = "";
+  for (let i = 0; i < u8.length; i++) {
+    s += String.fromCharCode(u8[i]);
+  }
+  return btoa(s);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloesce",
-  "version": "0.0.5-unstable.2",
+  "version": "0.0.5-unstable.3",
   "description": "A tool to extract and compile TypeScript code into something wrangler can consume and deploy for D1 Databases and Cloudflare Workers",
   "type": "module",
   "license": "Apache-2.0",