@space-df/sdk 0.0.1-dev.10

package/dist/src/_shims/auto/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export type Agent = any;
+
+// @ts-ignore
+declare const _fetch:                                        typeof fetch;
+export { _fetch as fetch };
+
+// @ts-ignore
+type _Request =                                   Request;
+export { _Request as Request };
+
+// @ts-ignore
+type _RequestInfo =                                       RequestInfo;
+export { type _RequestInfo as RequestInfo };
+
+// @ts-ignore
+type _RequestInit =                                       RequestInit;
+export { type _RequestInit as RequestInit };
+
+// @ts-ignore
+type _Response =                                    Response;
+export { _Response as Response };
+
+// @ts-ignore
+type _ResponseInit =                                        ResponseInit;
+export { type _ResponseInit as ResponseInit };
+
+// @ts-ignore
+type _ResponseType =                                        ResponseType;
+export { type _ResponseType as ResponseType };
+
+// @ts-ignore
+type _BodyInit =                                    BodyInit;
+export { type _BodyInit as BodyInit };
+
+// @ts-ignore
+type _Headers =                                   Headers;
+export { _Headers as Headers };
+
+// @ts-ignore
+type _HeadersInit =                                       HeadersInit;
+export { type _HeadersInit as HeadersInit };
+
+type EndingType = 'native' | 'transparent';
+
+export interface BlobPropertyBag {
+    endings?: EndingType;
+    type?: string;
+}
+
+export interface FilePropertyBag extends BlobPropertyBag {
+    lastModified?: number;
+}
+
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+// @ts-ignore
+type _FormData =                                    FormData;
+// @ts-ignore
+declare const _FormData:                                           typeof FormData;
+export { _FormData as FormData };
+
+// @ts-ignore
+type _File =                                File;
+// @ts-ignore
+declare const _File:                                       typeof File;
+export { _File as File };
+
+// @ts-ignore
+type _Blob =                                Blob;
+// @ts-ignore
+declare const _Blob:                                       typeof Blob;
+export { _Blob as Blob };
+
+export declare class Readable {
+    readable: boolean;
+    readonly readableEnded: boolean;
+    readonly readableFlowing: boolean | null;
+    readonly readableHighWaterMark: number;
+    readonly readableLength: number;
+    readonly readableObjectMode: boolean;
+    destroyed: boolean;
+    read(size?: number): any;
+    pause(): this;
+    resume(): this;
+    isPaused(): boolean;
+    destroy(error?: Error): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+}
+
+export declare class FsReadStream extends Readable {
+    path: object; // node type is string | Buffer
+}
+
+// @ts-ignore
+type _ReadableStream<R = any> =                                             ReadableStream<R>;
+// @ts-ignore
+declare const _ReadableStream:                                                 typeof ReadableStream;
+export { _ReadableStream as ReadableStream };

package/dist/src/_shims/auto/types.js

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/dist/src/_shims/auto/types.mjs

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/dist/src/_shims/bun-runtime.ts

@@ -0,0 +1,14 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+import { type Shims } from './registry';
+import { getRuntime as getWebRuntime } from './web-runtime';
+import { ReadStream as FsReadStream } from 'node:fs';
+
+export function getRuntime(): Shims {
+    const runtime = getWebRuntime();
+    function isFsReadStream(value: any): value is FsReadStream {
+        return value instanceof FsReadStream;
+    }
+    return { ...runtime, isFsReadStream };
+}

package/dist/src/_shims/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+import { manual } from './manual-types';
+import * as auto from "./auto/types";
+import { type RequestOptions } from '../core';
+
+type SelectType<Manual, Auto> = unknown extends Manual ? Auto : Manual;
+
+export const kind: string;
+
+export type Agent = SelectType<manual.Agent, auto.Agent>;
+
+export const fetch: SelectType<typeof manual.fetch, typeof auto.fetch>;
+
+// @ts-ignore-start
+export type Request = SelectType<manual.Request, auto.Request>;
+
+export type RequestInfo = SelectType<manual.RequestInfo, auto.RequestInfo>;
+
+export type RequestInit = SelectType<manual.RequestInit, auto.RequestInit>;
+
+export type Response = SelectType<manual.Response, auto.Response>;
+
+export type ResponseInit = SelectType<manual.ResponseInit, auto.ResponseInit>;
+
+export type ResponseType = SelectType<manual.ResponseType, auto.ResponseType>;
+
+export type BodyInit = SelectType<manual.BodyInit, auto.BodyInit>;
+
+export type Headers = SelectType<manual.Headers, auto.Headers>;
+
+export const Headers: SelectType<typeof manual.Headers, typeof auto.Headers>;
+
+export type HeadersInit = SelectType<manual.HeadersInit, auto.HeadersInit>;
+
+export type BlobPropertyBag = SelectType<manual.BlobPropertyBag, auto.BlobPropertyBag>;
+
+export type FilePropertyBag = SelectType<manual.FilePropertyBag, auto.FilePropertyBag>;
+
+export type FileFromPathOptions = SelectType<manual.FileFromPathOptions, auto.FileFromPathOptions>;
+
+export type FormData = SelectType<manual.FormData, auto.FormData>;
+
+export const FormData: SelectType<typeof manual.FormData, typeof auto.FormData>;
+
+export type File = SelectType<manual.File, auto.File>;
+
+export const File: SelectType<typeof manual.File, typeof auto.File>;
+
+export type Blob = SelectType<manual.Blob, auto.Blob>;
+
+export const Blob: SelectType<typeof manual.Blob, typeof auto.Blob>;
+
+export type Readable = SelectType<manual.Readable, auto.Readable>;
+
+export type FsReadStream = SelectType<manual.FsReadStream, auto.FsReadStream>;
+
+export type ReadableStream = SelectType<manual.ReadableStream, auto.ReadableStream>;
+
+export const ReadableStream: SelectType<typeof manual.ReadableStream, typeof auto.ReadableStream>;
+
+export type FileFromPathOptions = SelectType<manual.FileFromPathOptions, auto.FileFromPathOptions>;
+// @ts-ignore-start
+export function getMultipartRequestOptions<T = Record<string, unknown>>(form: FormData, opts: RequestOptions<T>): Promise<RequestOptions<T>>;
+
+export function getDefaultAgent(url: string): any;
+
+export function fileFromPath(path: string, options?: FileFromPathOptions): Promise<File>;
+export function fileFromPath(path: string, filename?: string, options?: FileFromPathOptions): Promise<File>;
+
+export function isFsReadStream(value: any): value is FsReadStream;

package/dist/src/_shims/index.js

@@ -0,0 +1,13 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+const shims = require('./registry');
+const auto = require('@space-df/sdk/_shims/auto/runtime');
+if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true });
+for (const property of Object.keys(shims)) {
+    Object.defineProperty(exports, property, {
+        get() {
+            return shims[property];
+        },
+    });
+}

package/dist/src/_shims/index.mjs

@@ -0,0 +1,7 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+import * as shims from './registry.mjs';
+import * as auto from "./auto/runtime";
+if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true });
+export * from './registry.mjs';

package/dist/src/_shims/manual-types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+/**
+ * Types will get added to this namespace when you import one of the following:
+ *
+ *   import 'spacedf-sdk/shims/node'
+ *   import 'spacedf-sdk/shims/web'
+ *
+ * Importing more than one will cause type and runtime errors.
+ */
+export namespace manual {}

package/dist/src/_shims/manual-types.js

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/dist/src/_shims/manual-types.mjs

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/dist/src/_shims/node-runtime.ts

@@ -0,0 +1,78 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+import * as nf from 'node-fetch';
+import * as fd from 'formdata-node';
+import { type File, type FilePropertyBag } from 'formdata-node';
+import KeepAliveAgent from 'agentkeepalive';
+import { AbortController as AbortControllerPolyfill } from 'abort-controller';
+import { ReadStream as FsReadStream } from 'node:fs';
+import { type Agent } from 'node:http';
+import { FormDataEncoder } from 'form-data-encoder';
+import { Readable } from 'node:stream';
+import { type RequestOptions } from '../core';
+import { MultipartBody } from './MultipartBody';
+import { type Shims } from './registry';
+import { ReadableStream } from 'node:stream/web';
+
+type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+let fileFromPathWarned = false;
+
+/**
+ * @deprecated use fs.createReadStream('./my/file.txt') instead
+ */
+async function fileFromPath(path: string): Promise<File>;
+async function fileFromPath(path: string, filename?: string): Promise<File>;
+async function fileFromPath(path: string, options?: FileFromPathOptions): Promise<File>;
+async function fileFromPath(path: string, filename?: string, options?: FileFromPathOptions): Promise<File>;
+async function fileFromPath(path: string, ...args: any[]): Promise<File> {
+    // this import fails in environments that don't handle export maps correctly, like old versions of Jest
+    const { fileFromPath: _fileFromPath } = await import('formdata-node/file-from-path');
+
+    if (!fileFromPathWarned) {
+        console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path)}) instead`);
+        fileFromPathWarned = true;
+    }
+    // @ts-ignore
+    return await _fileFromPath(path, ...args);
+}
+
+const defaultHttpAgent: Agent = new KeepAliveAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
+const defaultHttpsAgent: Agent = new KeepAliveAgent.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
+
+async function getMultipartRequestOptions<T = Record<string, unknown>>(form: fd.FormData, opts: RequestOptions<T>): Promise<RequestOptions<T>> {
+    const encoder = new FormDataEncoder(form);
+    const readable = Readable.from(encoder);
+    const body = new MultipartBody(readable);
+    const headers = {
+        ...opts.headers,
+        ...encoder.headers,
+        'Content-Length': encoder.contentLength,
+    };
+
+    return { ...opts, body: body as any, headers };
+}
+
+export function getRuntime(): Shims {
+    // Polyfill global object if needed.
+    if (typeof AbortController === 'undefined') {
+        // @ts-expect-error (the types are subtly different, but compatible in practice)
+        globalThis.AbortController = AbortControllerPolyfill;
+    }
+    return {
+        kind: 'node',
+        fetch: nf.default,
+        Request: nf.Request,
+        Response: nf.Response,
+        Headers: nf.Headers,
+        FormData: fd.FormData,
+        Blob: fd.Blob,
+        File: fd.File,
+        ReadableStream,
+        getMultipartRequestOptions,
+        getDefaultAgent: (url: string): Agent => (url.startsWith('https') ? defaultHttpsAgent : defaultHttpAgent),
+        fileFromPath,
+        isFsReadStream: (value: any): value is FsReadStream => value instanceof FsReadStream,
+    };
+}

package/dist/src/_shims/node-types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+import * as nf from 'node-fetch';
+import * as fd from 'formdata-node';
+
+export { type Agent } from 'node:http';
+export { type Readable } from 'node:stream';
+export { type ReadStream as FsReadStream } from 'node:fs';
+export { ReadableStream } from 'node:stream/web';
+
+export const fetch: typeof nf.default;
+
+export type Request = nf.Request;
+export type RequestInfo = nf.RequestInfo;
+export type RequestInit = nf.RequestInit;
+
+export type Response = nf.Response;
+export type ResponseInit = nf.ResponseInit;
+export type ResponseType = nf.ResponseType;
+export type BodyInit = nf.BodyInit;
+export type Headers = nf.Headers;
+export type HeadersInit = nf.HeadersInit;
+
+type EndingType = 'native' | 'transparent';
+export interface BlobPropertyBag {
+    endings?: EndingType;
+    type?: string;
+}
+
+export interface FilePropertyBag extends BlobPropertyBag {
+    lastModified?: number;
+}
+
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+export type FormData = fd.FormData;
+export const FormData: typeof fd.FormData;
+export type File = fd.File;
+export const File: typeof fd.File;
+export type Blob = fd.Blob;
+export const Blob: typeof fd.Blob;

package/dist/src/_shims/node-types.js

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/dist/src/_shims/node-types.mjs

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/dist/src/_shims/registry.ts

@@ -0,0 +1,60 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+import { type RequestOptions } from '../core';
+
+export interface Shims {
+    kind: string;
+    fetch: any;
+    Request: any;
+    Response: any;
+    Headers: any;
+    FormData: any;
+    Blob: any;
+    File: any;
+    ReadableStream: any;
+    getMultipartRequestOptions: <T = Record<string, unknown>>(form: Shims['FormData'], opts: RequestOptions<T>) => Promise<RequestOptions<T>>;
+    getDefaultAgent: (url: string) => any;
+    fileFromPath:
+        | ((path: string, filename?: string, options?: object) => Promise<Shims['File']>)
+        | ((path: string, options?: object) => Promise<Shims['File']>);
+    isFsReadStream: (value: any) => boolean;
+}
+
+export let auto = false;
+export let kind: Shims['kind'] | undefined = undefined;
+export let fetch: Shims['fetch'] | undefined = undefined;
+export let Request: Shims['Request'] | undefined = undefined;
+export let Response: Shims['Response'] | undefined = undefined;
+export let Headers: Shims['Headers'] | undefined = undefined;
+export let FormData: Shims['FormData'] | undefined = undefined;
+export let Blob: Shims['Blob'] | undefined = undefined;
+export let File: Shims['File'] | undefined = undefined;
+export let ReadableStream: Shims['ReadableStream'] | undefined = undefined;
+export let getMultipartRequestOptions: Shims['getMultipartRequestOptions'] | undefined = undefined;
+export let getDefaultAgent: Shims['getDefaultAgent'] | undefined = undefined;
+export let fileFromPath: Shims['fileFromPath'] | undefined = undefined;
+export let isFsReadStream: Shims['isFsReadStream'] | undefined = undefined;
+
+export function setShims(shims: Shims, options: { auto: boolean } = { auto: false }) {
+    if (auto) {
+        throw new Error(`you must \`import 'spacedf-sdk/shims/${shims.kind}'\` before importing anything else from spacedf-sdk`);
+    }
+    if (kind) {
+        throw new Error(`can't \`import 'spacedf-sdk/shims/${shims.kind}'\` after \`import 'spacedf-sdk/shims/${kind}'\``);
+    }
+    auto = options.auto;
+    kind = shims.kind;
+    fetch = shims.fetch;
+    Request = shims.Request;
+    Response = shims.Response;
+    Headers = shims.Headers;
+    FormData = shims.FormData;
+    Blob = shims.Blob;
+    File = shims.File;
+    ReadableStream = shims.ReadableStream;
+    getMultipartRequestOptions = shims.getMultipartRequestOptions;
+    getDefaultAgent = shims.getDefaultAgent;
+    fileFromPath = shims.fileFromPath;
+    isFsReadStream = shims.isFsReadStream;
+}

package/dist/src/_shims/web-runtime.ts

@@ -0,0 +1,91 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+import { MultipartBody } from './MultipartBody';
+import { type RequestOptions } from '../core';
+import { type Shims } from './registry';
+
+export function getRuntime({ manuallyImported }: { manuallyImported?: boolean } = {}): Shims {
+    const recommendation = manuallyImported
+        ? `You may need to use polyfills`
+        : `Add one of these imports before your first \`import … from 'spacedf-sdk'\`:
+- \`import 'spacedf-sdk/shims/node'\` (if you're running on Node)
+- \`import 'spacedf-sdk/shims/web'\` (otherwise)
+`;
+
+    let _fetch, _Request, _Response, _Headers;
+    try {
+        // @ts-ignore
+        _fetch = fetch;
+        // @ts-ignore
+        _Request = Request;
+        // @ts-ignore
+        _Response = Response;
+        // @ts-ignore
+        _Headers = Headers;
+    } catch (error) {
+        throw new Error(`this environment is missing the following Web Fetch API type: ${(error as any).message}. ${recommendation}`);
+    }
+
+    return {
+        kind: 'web',
+        fetch: _fetch,
+        Request: _Request,
+        Response: _Response,
+        Headers: _Headers,
+        FormData:
+            // @ts-ignore
+            typeof FormData !== 'undefined'
+                ? // @ts-ignore
+                  FormData
+                : class FormData {
+                      // @ts-ignore
+                      constructor() {
+                          throw new Error(`file uploads aren't supported in this environment yet as 'FormData' is undefined. ${recommendation}`);
+                      }
+                  },
+        Blob:
+            typeof Blob !== 'undefined'
+                ? Blob
+                : class Blob {
+                      constructor() {
+                          throw new Error(`file uploads aren't supported in this environment yet as 'Blob' is undefined. ${recommendation}`);
+                      }
+                  },
+        File:
+            // @ts-ignore
+            typeof File !== 'undefined'
+                ? // @ts-ignore
+                  File
+                : class File {
+                      // @ts-ignore
+                      constructor() {
+                          throw new Error(`file uploads aren't supported in this environment yet as 'File' is undefined. ${recommendation}`);
+                      }
+                  },
+        ReadableStream:
+            // @ts-ignore
+            typeof ReadableStream !== 'undefined'
+                ? // @ts-ignore
+                  ReadableStream
+                : class ReadableStream {
+                      // @ts-ignore
+                      constructor() {
+                          throw new Error(`streaming isn't supported in this environment yet as 'ReadableStream' is undefined. ${recommendation}`);
+                      }
+                  },
+        getMultipartRequestOptions: async <T = Record<string, unknown>>(
+            // @ts-ignore
+            form: FormData,
+            opts: RequestOptions<T>,
+        ): Promise<RequestOptions<T>> => ({
+            ...opts,
+            body: new MultipartBody(form) as any,
+        }),
+        getDefaultAgent: (url: string) => undefined,
+        fileFromPath: () => {
+            throw new Error('The `fileFromPath` function is only supported in Node.');
+        },
+        isFsReadStream: (value: any) => false,
+    };
+}

package/dist/src/_shims/web-types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export type Agent = any;
+
+declare const _fetch: typeof fetch;
+export { _fetch as fetch };
+
+type _Request = Request;
+export { _Request as Request };
+
+type _RequestInfo = RequestInfo;
+export { type _RequestInfo as RequestInfo };
+
+type _RequestInit = RequestInit;
+export { type _RequestInit as RequestInit };
+
+type _Response = Response;
+export { _Response as Response };
+
+type _ResponseInit = ResponseInit;
+export { type _ResponseInit as ResponseInit };
+
+type _ResponseType = ResponseType;
+export { type _ResponseType as ResponseType };
+
+type _BodyInit = BodyInit;
+export { type _BodyInit as BodyInit };
+
+type _Headers = Headers;
+export { _Headers as Headers };
+
+type _HeadersInit = HeadersInit;
+export { type _HeadersInit as HeadersInit };
+
+type EndingType = 'native' | 'transparent';
+
+export interface BlobPropertyBag {
+    endings?: EndingType;
+    type?: string;
+}
+
+export interface FilePropertyBag extends BlobPropertyBag {
+    lastModified?: number;
+}
+
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+type _FormData = FormData;
+declare const _FormData: typeof FormData;
+export { _FormData as FormData };
+
+type _File = File;
+declare const _File: typeof File;
+export { _File as File };
+
+type _Blob = Blob;
+declare const _Blob: typeof Blob;
+export { _Blob as Blob };
+
+export declare class Readable {
+    readable: boolean;
+    readonly readableEnded: boolean;
+    readonly readableFlowing: boolean | null;
+    readonly readableHighWaterMark: number;
+    readonly readableLength: number;
+    readonly readableObjectMode: boolean;
+    destroyed: boolean;
+    read(size?: number): any;
+    pause(): this;
+    resume(): this;
+    isPaused(): boolean;
+    destroy(error?: Error): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+}
+
+export declare class FsReadStream extends Readable {
+    path: object; // node type is string | Buffer
+}
+
+type _ReadableStream<R = any> = ReadableStream<R>;
+declare const _ReadableStream: typeof ReadableStream;
+export { _ReadableStream as ReadableStream };

package/dist/src/_shims/web-types.js

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/dist/src/_shims/web-types.mjs

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */