@poe-platform/safe-js 0.1.0

package/dist/safe-fs/fs/s3/http/types.d.ts

@@ -0,0 +1,30 @@
+import type { ClientRequest, IncomingMessage, RequestOptions } from "node:http";
+export interface S3HttpCredentials {
+    readonly accessKeyId: string;
+    readonly secretAccessKey: string;
+    readonly sessionToken?: string;
+}
+export type S3HttpCredentialProvider = (options: {
+    readonly signal: AbortSignal;
+}) => Promise<S3HttpCredentials>;
+export type S3HttpRequestFactory = (options: RequestOptions, onResponse: (response: IncomingMessage) => void) => ClientRequest;
+export interface S3HttpTransportOptions {
+    readonly endpoint: string;
+    readonly region: string;
+    readonly credentials: S3HttpCredentials | S3HttpCredentialProvider;
+    readonly addressingStyle?: "path" | "virtual-hosted";
+    readonly listUrlEncoding?: "percent" | "form";
+    readonly clock?: () => Date;
+    readonly request?: S3HttpRequestFactory;
+    readonly allowInsecureHttp?: boolean;
+    readonly maxPutBytes?: number;
+    readonly maxGetBytes?: number;
+    readonly maxXmlBytes?: number;
+    readonly requestTimeoutMs?: number;
+    readonly enableCopy?: boolean;
+    readonly verifiedConditionalOperations?: {
+        readonly put?: boolean;
+        readonly copy?: boolean;
+        readonly delete?: boolean;
+    };
+}

package/dist/safe-fs/fs/s3/index.d.ts

@@ -0,0 +1,6 @@
+export { S3FileSystem, S3RenameError } from "./filesystem.js";
+export type { S3FileSystemOptions } from "./filesystem.js";
+export { MockS3Client } from "./mock.js";
+export type { MockS3ClientOptions, MockS3Operation, MockS3Request } from "./mock.js";
+export { createS3Transport, encodeCopySource, S3ServiceError } from "./transport.js";
+export type { S3Body, S3Client, S3CopyInput, S3CopyOutput, S3DeleteInput, S3GetOutput, S3HeadOutput, S3ListInput, S3ListOutput, S3ObjectInput, S3ObjectSummary, S3PutInput, S3RequestOptions, S3Transport, S3TransportCapabilities, } from "./transport.js";

package/dist/safe-fs/fs/s3/mock.d.ts

@@ -0,0 +1,48 @@
+import type { S3StreamGetInput, S3StreamGetOutput, S3StreamPutInput } from "./transport.js";
+import type { S3CopyInput, S3CopyOutput, S3DeleteInput, S3GetOutput, S3HeadOutput, S3ListInput, S3ListOutput, S3ObjectInput, S3PutInput, S3RequestOptions, S3Transport } from "./transport.js";
+export type MockS3Operation = "headObject" | "getObject" | "putObject" | "deleteObject" | "copyObject" | "listObjectsV2";
+export interface MockS3Request {
+    readonly operation: MockS3Operation;
+    readonly input: S3ObjectInput | S3ListInput | S3CopyInput | S3PutInput | S3DeleteInput;
+}
+export interface MockS3ClientOptions {
+    readonly buckets: readonly string[];
+    readonly pageSize?: number;
+    readonly now?: () => Date;
+    readonly authorize?: (request: MockS3Request) => void | Promise<void>;
+}
+export declare class MockS3Client implements S3Transport {
+    readonly capabilities: Readonly<{
+        conditionalPut: true;
+        conditionalCopy: true;
+        conditionalDelete: true;
+        streamingRead: true;
+        streamingWrite: true;
+    }>;
+    private readonly buckets;
+    private readonly cursors;
+    private readonly history;
+    private readonly pageSize;
+    private readonly now;
+    private readonly authorize;
+    private nextToken;
+    constructor(options: MockS3ClientOptions);
+    get requests(): readonly MockS3Request[];
+    private begin;
+    private bucket;
+    private object;
+    private head;
+    private store;
+    headObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3HeadOutput>;
+    getObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3GetOutput>;
+    putObject(input: S3PutInput, options?: S3RequestOptions): Promise<{
+        ETag: string;
+    }>;
+    getObjectStream(input: S3StreamGetInput, options?: S3RequestOptions): Promise<S3StreamGetOutput>;
+    putObjectStream(input: S3StreamPutInput, options?: S3RequestOptions): Promise<{
+        ETag: string;
+    }>;
+    deleteObject(input: S3DeleteInput, options?: S3RequestOptions): Promise<Record<string, never>>;
+    copyObject(input: S3CopyInput, options?: S3RequestOptions): Promise<S3CopyOutput>;
+    listObjectsV2(input: S3ListInput, options?: S3RequestOptions): Promise<S3ListOutput>;
+}

package/dist/safe-fs/fs/s3/transport.d.ts

@@ -0,0 +1,103 @@
+export interface S3RequestOptions {
+    readonly abortSignal?: AbortSignal;
+}
+export interface S3ObjectInput {
+    readonly Bucket: string;
+    readonly Key: string;
+}
+export interface S3HeadOutput {
+    readonly ContentLength?: number | undefined;
+    readonly LastModified?: Date | undefined;
+    readonly ETag?: string | undefined;
+    readonly Metadata?: Record<string, string> | undefined;
+}
+export type S3Body = Uint8Array | AsyncIterable<Uint8Array> | {
+    transformToByteArray(): Promise<Uint8Array>;
+};
+export interface S3GetOutput extends S3HeadOutput {
+    readonly Body?: S3Body | undefined;
+}
+export interface S3StreamGetInput extends S3ObjectInput {
+    readonly Range?: string;
+    readonly IfMatch?: string;
+}
+export interface S3StreamGetOutput extends S3HeadOutput {
+    readonly Body: AsyncIterable<Uint8Array>;
+}
+export interface S3StreamPutInput extends Omit<S3PutInput, "Body"> {
+    readonly Body: AsyncIterable<Uint8Array>;
+}
+export interface S3PutInput extends S3ObjectInput {
+    readonly Body: Uint8Array;
+    readonly IfMatch?: string;
+    readonly IfNoneMatch?: "*";
+    readonly Metadata?: Record<string, string>;
+}
+export interface S3DeleteInput extends S3ObjectInput {
+    readonly IfMatch?: string;
+}
+export interface S3CopyInput extends S3ObjectInput {
+    readonly CopySource: string;
+    readonly CopySourceIfMatch?: string;
+    readonly IfNoneMatch?: "*";
+    readonly IfMatch?: string;
+    readonly MetadataDirective?: "COPY" | "REPLACE";
+    readonly Metadata?: Record<string, string>;
+}
+export interface S3CopyOutput {
+    readonly CopyObjectResult?: {
+        readonly ETag?: string | undefined;
+        readonly LastModified?: Date | undefined;
+    } | undefined;
+}
+export interface S3ListInput {
+    readonly Bucket: string;
+    readonly Prefix?: string;
+    readonly Delimiter?: string;
+    readonly MaxKeys?: number;
+    readonly ContinuationToken?: string;
+}
+export interface S3ObjectSummary {
+    readonly Key?: string | undefined;
+    readonly Size?: number | undefined;
+    readonly ETag?: string | undefined;
+    readonly LastModified?: Date | undefined;
+}
+export interface S3ListOutput {
+    readonly Contents?: readonly S3ObjectSummary[] | undefined;
+    readonly CommonPrefixes?: readonly {
+        readonly Prefix?: string | undefined;
+    }[] | undefined;
+    readonly IsTruncated?: boolean | undefined;
+    readonly NextContinuationToken?: string | undefined;
+    readonly KeyCount?: number | undefined;
+}
+export interface S3Client {
+    getObjectStream?(input: S3StreamGetInput, options?: S3RequestOptions): Promise<S3StreamGetOutput>;
+    putObjectStream?(input: S3StreamPutInput, options?: S3RequestOptions): Promise<unknown>;
+    headObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3HeadOutput>;
+    getObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3GetOutput>;
+    putObject(input: S3PutInput, options?: S3RequestOptions): Promise<unknown>;
+    deleteObject(input: S3DeleteInput, options?: S3RequestOptions): Promise<unknown>;
+    copyObject(input: S3CopyInput, options?: S3RequestOptions): Promise<S3CopyOutput>;
+    listObjectsV2(input: S3ListInput, options?: S3RequestOptions): Promise<S3ListOutput>;
+}
+export interface S3TransportCapabilities {
+    readonly streamingRead?: boolean;
+    readonly streamingWrite?: boolean;
+    readonly conditionalPut?: boolean;
+    readonly conditionalCopy?: boolean;
+    readonly conditionalDelete?: boolean;
+}
+export interface S3Transport extends S3Client {
+    readonly capabilities?: S3TransportCapabilities;
+}
+export declare function createS3Transport(client: S3Client, capabilities?: S3TransportCapabilities): S3Transport;
+export declare class S3ServiceError extends Error {
+    readonly code: string;
+    readonly $metadata: {
+        readonly httpStatusCode: number;
+    };
+    constructor(code: string, status: number, message?: string);
+}
+export declare function encodeCopySource(bucket: string, key: string): string;

package/dist/safe-fs/fs/webdav/index.d.ts

@@ -0,0 +1,2 @@
+export { WebDavFileSystem } from "./webdav.js";
+export type { WebDavFileSystemOptions, WebDavFetch, WebDavAtomicEmptyDirectoryBinding, WebDavAtomicEmptyDirectoryRequest, WebDavAtomicEmptyDirectoryResult, } from "./webdav.js";

package/dist/safe-fs/fs/webdav/webdav.d.ts

@@ -0,0 +1,101 @@
+import type { PlatformComparisonCallback } from "#safe-fs-platform";
+import type { ByteSource } from "../../contracts/io.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+export type WebDavFetch = (url: string, init: RequestInit) => Promise<Response>;
+export interface WebDavAtomicEmptyDirectoryRequest {
+    readonly operation: "atomic-empty-rmdir/v1";
+    readonly namespaceUrl: string;
+    readonly path: string;
+    readonly signal?: AbortSignal;
+}
+export interface WebDavAtomicEmptyDirectoryResult {
+    readonly operation: "atomic-empty-rmdir/v1";
+    readonly namespaceUrl: string;
+    readonly path: string;
+    readonly outcome: "removed";
+}
+export interface WebDavAtomicEmptyDirectoryBinding {
+    readonly namespaceUrl: string;
+    readonly removeEmptyDirectory: (request: WebDavAtomicEmptyDirectoryRequest) => Promise<WebDavAtomicEmptyDirectoryResult>;
+}
+export interface WebDavFileSystemOptions {
+    readonly baseUrl: string;
+    readonly fetch: WebDavFetch;
+    readonly requestStreamSupport?: "native" | boolean;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly maxResponseBytes?: number;
+    readonly maxXmlBytes?: number;
+    readonly maxEntries?: number;
+    readonly timeoutMs?: number;
+    readonly overwritePolicy?: "lock" | "etag";
+    readonly atomicEmptyDirectory?: WebDavAtomicEmptyDirectoryBinding;
+    readonly compareEntry?: PlatformComparisonCallback<(this: FileSystem, ...args: Parameters<NonNullable<FileSystem["compareEntry"]>>) => ReturnType<NonNullable<FileSystem["compareEntry"]>>>;
+}
+export declare class WebDavFileSystem implements FileSystem {
+    readonly capabilities: Readonly<{
+        symlinks: false;
+        hardlinks: false;
+        permissions: false;
+        timestamps: true;
+        atomicRename: false;
+        streamingRead: true;
+        streamingWrite: true;
+    }>;
+    private readonly base;
+    private readonly baseSegments;
+    private readonly transport;
+    private readonly requestStreamSupport;
+    private readonly headers;
+    private readonly maxResponseBytes;
+    private readonly maxXmlBytes;
+    private readonly maxEntries;
+    private readonly timeoutMs;
+    private readonly overwritePolicy;
+    private readonly configuredComparison;
+    private readonly atomicEmptyDirectory;
+    private readonly etags;
+    constructor(options: WebDavFileSystemOptions);
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
+    private resourceId;
+    private url;
+    private hrefPath;
+    private httpError;
+    private request;
+    private requestStream;
+    private bytes;
+    private bodyChunks;
+    private xml;
+    private multistatus;
+    private lockFailure;
+    private entryStat;
+    private entries;
+    private mutation;
+    private unsupported;
+    private maybeStat;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    readStream(path: string, options?: ReadStreamOptions): AsyncGenerator<Uint8Array>;
+    private prepareWrite;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    private atomicRmdir;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    private guardTransferIdentity;
+    private transfer;
+    private withDestinationLock;
+    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, _options?: FsOptions): Promise<string>;
+    symlink(_target: string, path: string, _options?: FsOptions): Promise<void>;
+    link(_source: string, path: string, _options?: FsOptions): Promise<void>;
+    chmod(path: string, _mode: number, _options?: FsOptions): Promise<void>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, _length?: number, _options?: FsOptions): Promise<void>;
+}

package/dist/safe-fs/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./contracts/index.js";
+export * from "./fs/memory/index.js";
+export * from "./fs/real/index.js";
+export * from "./fs/s3/index.js";
+export type { S3StreamGetInput, S3StreamGetOutput, S3StreamPutInput } from "./fs/s3/transport.js";
+export * from "./fs/s3/http/index.js";
+export * from "./fs/webdav/index.js";
+export * from "./fs/readonly/index.js";
+export * from "./fs/mount/index.js";
+export * from "./fs/overlay/index.js";
+export * from "./node/index.js";
+export { createFileSystem, readConfigRecord, validateFileSystemConfig } from "./config.js";
+export type { FileSystemConfig, FileSystemAdapterDescriptor, FileSystemAdapterRegistry } from "./config.js";
+export { createNodeFileSystemAdapterRegistry } from "./config.node.js";

package/dist/safe-fs/node/filesystem.d.ts

@@ -0,0 +1,11 @@
+import type * as FsPromises from "node:fs/promises";
+import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export type NodeFsImplementation = Pick<typeof FsPromises, "access" | "appendFile" | "chmod" | "copyFile" | "cp" | "link" | "lstat" | "mkdir" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "rename" | "rm" | "rmdir" | "stat" | "symlink" | "truncate" | "utimes" | "writeFile">;
+export interface NodeFsBridgeOptions {
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+}
+export interface NodeFsBridgeFileSystem extends FileSystem {
+    rmdir?(path: string, options?: FsOptions): Promise<void>;
+}
+export declare function createNodeFsBridge(fs: FileSystem, options?: NodeFsBridgeOptions): NodeFsImplementation;

package/dist/safe-fs/node/index.d.ts

@@ -0,0 +1,2 @@
+export { createNodeFsBridge } from "./filesystem.js";
+export type { NodeFsBridgeOptions, NodeFsBridgeFileSystem, NodeFsImplementation } from "./filesystem.js";

package/dist/safe-fs/node-host.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist/safe-fs/node-unavailable.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/safe-fs/platform/browser.d.ts

@@ -0,0 +1,12 @@
+import type { FsOptions } from "../contracts/filesystem.js";
+export type PlatformErrno = number | undefined;
+export type PlatformComparisonCallback<Callback> = Callback & never;
+export declare const platform: Readonly<{
+    errno(_code: string): PlatformErrno;
+    callbackAuthorities: false;
+    randomUUID(): string;
+}>;
+export declare const comparisonContext: Readonly<{
+    active(options: FsOptions): boolean;
+    run<Result>(options: FsOptions, action: (nested: FsOptions) => Promise<Result>): Promise<Result>;
+}>;

package/dist/safe-fs/platform/node.d.ts

@@ -0,0 +1,13 @@
+import { randomUUID } from "node:crypto";
+import type { FsOptions } from "../contracts/filesystem.js";
+export type PlatformErrno = number;
+export type PlatformComparisonCallback<Callback> = Callback;
+export declare const platform: Readonly<{
+    errno(code: string): PlatformErrno;
+    callbackAuthorities: true;
+    randomUUID: typeof randomUUID;
+}>;
+export declare const comparisonContext: Readonly<{
+    active(_options: FsOptions): boolean;
+    run<Result>(options: FsOptions, action: (nested: FsOptions) => Promise<Result>): Promise<Result>;
+}>;