@stacksjs/storage 0.70.161 → 0.70.163

package/dist/adapters/s3.d.ts

@@ -1,10 +1,33 @@
 import { Buffer } from 'node:buffer';
 import type { ChecksumOptions, DirectoryListing, FileContents, GetStreamOptions, ListOptions, MimeTypeOptions, PresignedUploadPolicy, PresignedUploadPolicyOptions, PresignedUploadUrl, PresignedUploadUrlOptions, PublicUrlOptions, PutResult, PutStreamOptions, SignedUrlOptions, StatEntry, StorageAdapter, StorageAdapterConfig, TemporaryUrlOptions, Visibility } from '../types';
 import type { S3Client } from '@stacksjs/ts-cloud';
+/**
+ * Build ts-cloud `S3ClientOptions` from adapter config, or `undefined` for a
+ * plain AWS S3 client. The config endpoint may carry a scheme
+ * (`https://s3.filebase.com`); ts-cloud wants a scheme-less host, so it's
+ * stripped here. This is what routes the adapter to S3-compatible providers -
+ * Filebase, Backblaze B2, Cloudflare R2, Hetzner Object Storage
+ * (stacksjs/stacks#938, #1897, #1896).
+ */
+export declare function resolveS3ClientOptions(config: {
+  endpoint?: string
+  usePathStyleEndpoint?: boolean
+  credentials?: { accessKeyId: string, secretAccessKey: string, sessionToken?: string }
+}): S3ClientOptions | undefined;
 /**
  * Create an S3 storage adapter instance
  */
 export declare function createS3Storage(client: S3Client | null, config: StorageAdapterConfig): S3StorageAdapter;
+/**
+ * Options for the ts-cloud S3 client. Mirrors ts-cloud's internal
+ * `S3ClientOptions` (declared but not re-exported from its package root);
+ * structural typing lets this satisfy the `S3Client` constructor's 3rd argument.
+ */
+declare interface S3ClientOptions {
+  endpoint?: string
+  forcePathStyle?: boolean
+  credentials?: { accessKeyId: string, secretAccessKey: string, sessionToken?: string }
+}
 /**
  * Append-and-take byte buffer used by the multipart pipeline
  * (stacksjs/stacks#1886). Holds incoming chunks until they reach

package/dist/adapters/s3.js

@@ -59,6 +59,16 @@ async function isSettled(p) {
     Promise.resolve(sentinel)
   ]) !== sentinel;
 }
+export function resolveS3ClientOptions(config) {
+  const options = {};
+  if (config.endpoint)
+    options.endpoint = config.endpoint.replace(/^https?:\/\//i, "").replace(/\/+$/, "");
+  if (config.usePathStyleEndpoint)
+    options.forcePathStyle = !0;
+  if (config.credentials)
+    options.credentials = config.credentials;
+  return Object.keys(options).length > 0 ? options : void 0;
+}
 
 export class S3StorageAdapter {
   _client;
@@ -66,6 +76,8 @@ export class S3StorageAdapter {
   bucket;
   prefix;
   region;
+  endpoint;
+  usePathStyleEndpoint;
   credentials;
   constructor(client, config) {
     this._client = client;
@@ -73,6 +85,8 @@ export class S3StorageAdapter {
     this.prefix = config.prefix || "";
     this.region = config.region || "us-east-1";
     this.credentials = config.credentials;
+    this.endpoint = config.endpoint;
+    this.usePathStyleEndpoint = config.usePathStyleEndpoint;
     if (!this.bucket)
       throw Error("S3 bucket name is required");
   }
@@ -81,7 +95,7 @@ export class S3StorageAdapter {
       return this._client;
     if (!this._clientPromise)
       this._clientPromise = import("@stacksjs/ts-cloud").then((cloud) => {
-        this._client = new cloud.S3Client(this.region);
+        this._client = new cloud.S3Client(this.region, void 0, resolveS3ClientOptions({ endpoint: this.endpoint, usePathStyleEndpoint: this.usePathStyleEndpoint, credentials: this.credentials }));
         return this._client;
       });
     return this._clientPromise;

package/dist/facade.js

@@ -87,7 +87,10 @@ class StorageManager {
     return new S3StorageAdapter(null, {
       bucket: config.bucket,
       region: config.region,
-      prefix: config.prefix
+      prefix: config.prefix,
+      endpoint: config.endpoint,
+      usePathStyleEndpoint: config.usePathStyleEndpoint,
+      credentials: config.credentials ? { accessKeyId: config.credentials.key, secretAccessKey: config.credentials.secret } : void 0
     });
   }
   async put(pathOrFile, contentsOrOpts) {

package/dist/image.d.ts

@@ -1,55 +1,31 @@
-/**
- * Wrap a Sharp pipeline so it composes with
- * `Storage.put(file, { transform })`. The pipeline function receives a
- * fresh Sharp instance preloaded with the file's bytes; its return
- * value is the final pipeline chain (sharp's methods are chainable so
- * "return img.resize(...)" is the normal shape).
- *
- * The wrapper handles the buffer normalisation + final `.toBuffer()`
- * call so callers don't have to.
- */
-export declare function transform(pipeline: (img: SharpInstance) => SharpInstance | Promise<SharpInstance>): (input: Uint8Array | Buffer | ArrayBuffer) => Promise<Buffer>;
-/**
- * Common preset for square avatars — resizes + crops to fit, encodes
- * as WebP at quality 85. Covers the by-far most common
- * `Storage.put(file, { transform: ... })` callsite.
- *
- * @example
- * ```ts
- * import { avatar } from '@stacksjs/storage/image'
- *
- * await Storage.put(file, {
- *   dir: 'avatars',
- *   transform: avatar(512),
- * })
- * ```
- */
+import type { ResizeFit } from 'ts-images';
+export declare function transform(pipeline: (image: NativeImagePipeline) => NativeImagePipeline | Promise<NativeImagePipeline>): (input: Uint8Array | Buffer | ArrayBuffer) => Promise<Buffer>;
 export declare function avatar(size?: number, quality?: number): (input: Uint8Array | Buffer | ArrayBuffer) => Promise<Buffer>;
-/**
- * Generic resize preset. `fit` defaults to `'inside'` (preserve aspect
- * ratio, don't crop) which is the most common non-avatar case.
- */
-export declare function resize(width: number, height: number, fit?: 'cover' | 'contain' | 'fill' | 'inside' | 'outside'): (input: Uint8Array | Buffer | ArrayBuffer) => Promise<Buffer>;
-/**
- * Strip EXIF + colour profile + other embedded metadata. Useful when
- * accepting user uploads where you don't want to leak GPS coordinates
- * embedded in phone photos. Pairs well with resize/format presets via
- * the explicit `transform()` form when needed.
- *
- * sharp strips metadata by default unless `withMetadata()` is called;
- * this preset just makes the intent explicit.
- */
-export declare function stripMetadata(): (input: Uint8Array | Buffer | ArrayBuffer) => Promise<Buffer>;
-declare interface SharpInstance {
-  toBuffer(): Promise<Buffer>
-  resize: (...args: unknown[]) => SharpInstance
-  jpeg: (...args: unknown[]) => SharpInstance
-  png: (...args: unknown[]) => SharpInstance
-  webp: (...args: unknown[]) => SharpInstance
-  avif: (...args: unknown[]) => SharpInstance
-  gif: (...args: unknown[]) => SharpInstance
-  rotate: (...args: unknown[]) => SharpInstance
-  blur: (...args: unknown[]) => SharpInstance
-  withMetadata: (...args: unknown[]) => SharpInstance
-  [k: string]: unknown
+export declare function resize(width: number, height: number, fit?: ResizeFit): (input: Uint8Array | Buffer | ArrayBuffer) => Promise<Buffer>;
+export declare function stripMetadata(format?: NativeImageFormat): (input: Uint8Array | Buffer | ArrayBuffer) => Promise<Buffer>;
+export declare interface NativeEncodeOptions { quality?: number, progressive?: boolean, lossless?: boolean, effort?: number }
+export declare interface NativeResizeOptions { fit?: ResizeFit, withoutEnlargement?: boolean }
+export declare interface NativeImagePipeline {
+  resize: (width?: number, height?: number, options?: NativeResizeOptions) => NativeImagePipeline
+  jpeg: (options?: NativeEncodeOptions) => NativeImagePipeline
+  png: (options?: NativeEncodeOptions) => NativeImagePipeline
+  webp: (options?: NativeEncodeOptions) => NativeImagePipeline
+  avif: (options?: NativeEncodeOptions) => NativeImagePipeline
+  rotate: (degrees?: number) => NativeImagePipeline
+  blur: (sigma?: number) => NativeImagePipeline
+  withMetadata: () => NativeImagePipeline
+  toBuffer: () => Promise<Buffer>
+}
+export type NativeImageFormat = 'jpeg' | 'png' | 'webp' | 'avif';
+declare class Pipeline implements NativeImagePipeline {
+  constructor(input: Uint8Array);
+  resize(width?: number, height?: number, options?: NativeResizeOptions): NativeImagePipeline;
+  jpeg(options?: NativeEncodeOptions): NativeImagePipeline;
+  png(options?: NativeEncodeOptions): NativeImagePipeline;
+  webp(options?: NativeEncodeOptions): NativeImagePipeline;
+  avif(options?: NativeEncodeOptions): NativeImagePipeline;
+  rotate(degrees?: number): NativeImagePipeline;
+  blur(sigma?: number): NativeImagePipeline;
+  withMetadata(): NativeImagePipeline;
+  toBuffer(): Promise<Buffer>;
 }

package/dist/image.js

@@ -1,29 +1,81 @@
-let cachedSharp = null;
-async function loadSharp() {
-  if (cachedSharp)
-    return cachedSharp;
-  try {
-    const mod = await import("sharp");
-    cachedSharp = mod.default ?? mod;
-    return cachedSharp;
-  } catch (err) {
-    throw Error(`[storage/image] \`sharp\` is not installed. Image transforms require it as a peer dependency.
-  Install with: \`bun add sharp\`
-  Original load error: ${err instanceof Error ? err.message : String(err)}`);
+import { blur as applyBlur, decode, encode, resize as applyResize, rotate as applyRotate } from "ts-images";
+
+class Pipeline {
+  input;
+  operations = [];
+  format = "webp";
+  options = { quality: 80 };
+  constructor(input) {
+    this.input = input;
+  }
+  resize(width, height, options = {}) {
+    if (width !== void 0 && (!Number.isInteger(width) || width <= 0))
+      throw TypeError("Image width must be positive");
+    if (height !== void 0 && (!Number.isInteger(height) || height <= 0))
+      throw TypeError("Image height must be positive");
+    if (width === void 0 && height === void 0)
+      throw TypeError("Image resize requires a width or height");
+    this.operations.push((image) => {
+      if (options.withoutEnlargement !== !1 && (width === void 0 || width >= image.width) && (height === void 0 || height >= image.height))
+        return image;
+      return applyResize(image, { width, height, fit: options.fit ?? "inside" });
+    });
+    return this;
+  }
+  jpeg(options = {}) {
+    return this.output("jpeg", options);
+  }
+  png(options = {}) {
+    return this.output("png", options);
+  }
+  webp(options = {}) {
+    return this.output("webp", options);
+  }
+  avif(options = {}) {
+    return this.output("avif", options);
+  }
+  rotate(degrees = 90) {
+    if (!Number.isFinite(degrees))
+      throw TypeError("Image rotation must be finite");
+    this.operations.push((image) => applyRotate(image, degrees));
+    return this;
+  }
+  blur(sigma = 1) {
+    if (!Number.isFinite(sigma) || sigma <= 0)
+      throw TypeError("Image blur sigma must be positive");
+    this.operations.push((image) => applyBlur(image, sigma));
+    return this;
+  }
+  withMetadata() {
+    throw Error("Native image transforms strip metadata for privacy");
+  }
+  async toBuffer() {
+    let image = await decode(this.input);
+    for (const operation of this.operations)
+      image = operation(image);
+    return Buffer.from(await encode(image, this.format, this.options));
+  }
+  output(format, options) {
+    const quality = options.quality ?? 80;
+    if (!Number.isFinite(quality) || quality < 1 || quality > 100)
+      throw TypeError("Image quality must be between 1 and 100");
+    this.format = format;
+    this.options = { ...options, quality };
+    return this;
   }
 }
 export function transform(pipeline) {
   return async (input) => {
-    const sharp = await loadSharp(), bytes = input instanceof ArrayBuffer ? new Uint8Array(input) : input, buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes), img = sharp(buf);
-    return (await pipeline(img)).toBuffer();
+    const bytes = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    return (await pipeline(new Pipeline(bytes))).toBuffer();
   };
 }
 export function avatar(size = 512, quality = 85) {
-  return transform((img) => img.resize(size, size, { fit: "cover" }).webp({ quality }));
+  return transform((image) => image.resize(size, size, { fit: "cover" }).webp({ quality }));
 }
 export function resize(width, height, fit = "inside") {
-  return transform((img) => img.resize(width, height, { fit }));
+  return transform((image) => image.resize(width, height, { fit }).webp());
 }
-export function stripMetadata() {
-  return transform((img) => img);
+export function stripMetadata(format = "webp") {
+  return transform((image) => image[format]());
 }

package/dist/index.d.ts

@@ -36,7 +36,7 @@ export { serveFile } from './static-serve';
 export { Storage, StorageManager } from './facade';
 export { UploadedFile, uploadedFile, uploadedFiles } from './uploaded-file';
 // Filesystem type helpers
-export { configFromEnv, localDisk, s3Disk } from './types/filesystem';
+export { backblazeDisk, configFromEnv, filebaseDisk, hetznerDisk, localDisk, r2Disk, s3Disk } from './types/filesystem';
 // Signed-URL helpers (used by Storage.disk('local').signedUrl())
 export {
   clearRevokedSignedStorageTokens,

package/dist/index.js

@@ -14,7 +14,7 @@ export * from "./drivers";
 export { serveFile } from "./static-serve";
 export { Storage, StorageManager } from "./facade";
 export { UploadedFile, uploadedFile, uploadedFiles } from "./uploaded-file";
-export { configFromEnv, localDisk, s3Disk } from "./types/filesystem";
+export { backblazeDisk, configFromEnv, filebaseDisk, hetznerDisk, localDisk, r2Disk, s3Disk } from "./types/filesystem";
 export {
   clearRevokedSignedStorageTokens,
   createSignedStorageToken,

package/dist/types/filesystem.d.ts

@@ -6,6 +6,44 @@ export declare function localDisk(root: string, options?: Partial<Omit<LocalDisk
  * Helper to create an S3 disk config
  */
 export declare function s3Disk(bucket: string, options?: Partial<Omit<S3DiskConfig, 'driver' | 'bucket'>>): S3DiskConfig;
+/**
+ * Helper to create a Filebase disk config (stacksjs/stacks#938).
+ *
+ * Filebase (https://filebase.com) is an S3-compatible, IPFS-backed object
+ * store, so it reuses the `s3` adapter with the endpoint pinned to
+ * `https://s3.filebase.com` and the region to `us-east-1` (Filebase's single
+ * S3 region). Pass a Filebase bucket; supply Filebase credentials via
+ * `options.credentials` or the standard `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY`
+ * env vars. Any field (prefix, visibility, credentials, ...) can be overridden.
+ */
+export declare function filebaseDisk(bucket: string, options?: Partial<Omit<S3DiskConfig, 'driver' | 'bucket'>>): S3DiskConfig;
+/**
+ * Helper to create a Backblaze B2 disk config (stacksjs/stacks#1897).
+ *
+ * Backblaze B2 exposes an S3-compatible API, so it reuses the `s3` adapter.
+ * `region` is the B2 region embedded in the endpoint (e.g. `us-west-004`,
+ * `eu-central-003`); the endpoint resolves to `https://s3.<region>.backblazeb2.com`.
+ * Supply B2 application key credentials via `options.credentials` or the AWS_* env vars.
+ */
+export declare function backblazeDisk(bucket: string, region: string, options?: Partial<Omit<S3DiskConfig, 'driver' | 'bucket'>>): S3DiskConfig;
+/**
+ * Helper to create a Cloudflare R2 disk config (stacksjs/stacks#1896).
+ *
+ * R2 exposes an S3-compatible API, so it reuses the `s3` adapter. R2 has a
+ * single logical region (`auto`) and a per-account endpoint
+ * `https://<accountId>.r2.cloudflarestorage.com`. Supply R2 token credentials
+ * via `options.credentials` or the AWS_* env vars.
+ */
+export declare function r2Disk(bucket: string, accountId: string, options?: Partial<Omit<S3DiskConfig, 'driver' | 'bucket'>>): S3DiskConfig;
+/**
+ * Helper to create a Hetzner Object Storage disk config (stacksjs/stacks#1897).
+ *
+ * Hetzner Object Storage exposes an S3-compatible API, so it reuses the `s3`
+ * adapter. `location` is the datacenter (e.g. `fsn1`, `nbg1`, `hel1`), used as
+ * both the region and the endpoint host `https://<location>.your-objectstorage.com`.
+ * Supply Hetzner S3 credentials via `options.credentials` or the AWS_* env vars.
+ */
+export declare function hetznerDisk(bucket: string, location: string, options?: Partial<Omit<S3DiskConfig, 'driver' | 'bucket'>>): S3DiskConfig;
 /**
  * Create filesystem config from environment variables
  */

package/dist/types/filesystem.js

@@ -15,6 +15,46 @@ export function s3Disk(bucket, options) {
     ...options
   };
 }
+export function filebaseDisk(bucket, options) {
+  return {
+    driver: "s3",
+    bucket,
+    region: "us-east-1",
+    endpoint: "https://s3.filebase.com",
+    visibility: "private",
+    ...options
+  };
+}
+export function backblazeDisk(bucket, region, options) {
+  return {
+    driver: "s3",
+    bucket,
+    region,
+    endpoint: `https://s3.${region}.backblazeb2.com`,
+    visibility: "private",
+    ...options
+  };
+}
+export function r2Disk(bucket, accountId, options) {
+  return {
+    driver: "s3",
+    bucket,
+    region: "auto",
+    endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+    visibility: "private",
+    ...options
+  };
+}
+export function hetznerDisk(bucket, location, options) {
+  return {
+    driver: "s3",
+    bucket,
+    region: location,
+    endpoint: `https://${location}.your-objectstorage.com`,
+    visibility: "private",
+    ...options
+  };
+}
 export function configFromEnv(base = {}) {
   const env = process.env;
   return {

package/dist/types.d.ts

@@ -178,6 +178,8 @@ export declare interface StorageAdapterConfig {
   bucket?: string
   region?: string
   prefix?: string
+  endpoint?: string
+  usePathStyleEndpoint?: boolean
   credentials?: {
     accessKeyId: string
     secretAccessKey: string

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/storage",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.161",
+  "version": "0.70.163",
   "description": "The Stacks file system.",
   "author": "Chris Breuer",
   "contributors": [
@@ -52,23 +52,15 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/ts-cloud": "^0.7.49"
-  },
-  "peerDependencies": {
-    "sharp": "^0.35.3"
-  },
-  "peerDependenciesMeta": {
-    "sharp": {
-      "optional": true
-    }
+    "@stacksjs/ts-cloud": "^0.7.56",
+    "ts-images": "^0.1.11"
   },
   "devDependencies": {
-    "@stacksjs/arrays": "0.70.161",
+    "@stacksjs/arrays": "0.70.163",
     "better-dx": "^0.2.17",
-    "@stacksjs/error-handling": "0.70.161",
-    "@stacksjs/path": "0.70.161",
-    "@stacksjs/strings": "0.70.161",
-    "@stacksjs/types": "0.70.161",
-    "sharp": "^0.35.3"
+    "@stacksjs/error-handling": "0.70.163",
+    "@stacksjs/path": "0.70.163",
+    "@stacksjs/strings": "0.70.163",
+    "@stacksjs/types": "0.70.163"
   }
 }