@cedarjs/uploads 7.0.0-canary.3114

package/dist/web/components/DbInput.d.ts

@@ -0,0 +1,18 @@
+import type { InputHTMLAttributes } from 'react';
+import type { DbUploadFile } from '../hooks/useDbUpload.js';
+export interface DbInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'onChange' | 'accept' | 'multiple' | 'onError'> {
+    allowedMimeTypes: string[];
+    maxFileSize: number;
+    maxFiles?: number;
+    /** Called with every selected file read as base64. */
+    onFilesReady?: (files: DbUploadFile[]) => void;
+    /** Called when a selected file fails validation or cannot be read. */
+    onReadError?: (error: Error) => void;
+}
+/**
+ * A file input for the DB upload path. Selected files are validated against
+ * the profile's constraints and read as base64, ready to send through a
+ * GraphQL mutation to `storeFile()`.
+ */
+export declare function DbInput({ allowedMimeTypes, maxFileSize, maxFiles, onFilesReady, onReadError, disabled, ...inputProps }: DbInputProps): import("react").JSX.Element;
+//# sourceMappingURL=DbInput.d.ts.map

package/dist/web/components/DbInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DbInput.d.ts","sourceRoot":"","sources":["../../../src/web/components/DbInput.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,mBAAmB,EAAE,MAAM,OAAO,CAAA;AAG7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE3D,MAAM,WAAW,YAAa,SAAQ,IAAI,CACxC,mBAAmB,CAAC,gBAAgB,CAAC,EACrC,MAAM,GAAG,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CACxD;IACC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,sDAAsD;IACtD,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,IAAI,CAAA;IAC9C,sEAAsE;IACtE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACrC;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,EACtB,gBAAgB,EAChB,WAAW,EACX,QAAY,EACZ,YAAY,EACZ,WAAW,EACX,QAAQ,EACR,GAAG,UAAU,EACd,EAAE,YAAY,+BAqCd"}

package/dist/web/components/DbInput.js

@@ -0,0 +1,46 @@
+import { jsx } from "react/jsx-runtime";
+import { useDbUpload } from "../hooks/useDbUpload.js";
+function DbInput({
+  allowedMimeTypes,
+  maxFileSize,
+  maxFiles = 1,
+  onFilesReady,
+  onReadError,
+  disabled,
+  ...inputProps
+}) {
+  const { readFiles, isReading } = useDbUpload({
+    allowedMimeTypes,
+    maxFileSize,
+    maxFiles
+  });
+  const onChange = async (event) => {
+    const input = event.target;
+    const files = input.files;
+    if (!files || files.length === 0) {
+      return;
+    }
+    try {
+      const ready = await readFiles(files);
+      onFilesReady?.(ready);
+    } catch (e) {
+      onReadError?.(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      input.value = "";
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      ...inputProps,
+      type: "file",
+      accept: allowedMimeTypes.join(","),
+      multiple: maxFiles > 1,
+      disabled: disabled || isReading,
+      onChange
+    }
+  );
+}
+export {
+  DbInput
+};

package/dist/web/components/FsUploader.d.ts

@@ -0,0 +1,6 @@
+import type { UseFsUploadOptions } from '../hooks/useFsUpload.js';
+import type { UppyUploaderProps } from './UppyUploader.js';
+export type FsUploaderProps = UseFsUploadOptions & Omit<UppyUploaderProps, 'uppy'>;
+/** Through-the-api uploader for FS targets: `useFsUpload` wired to an Uppy UI. */
+export declare function FsUploader({ profile, endpoint, onUploadComplete, onUploadError, ...uiProps }: FsUploaderProps): import("react").JSX.Element;
+//# sourceMappingURL=FsUploader.d.ts.map

package/dist/web/components/FsUploader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FsUploader.d.ts","sourceRoot":"","sources":["../../../src/web/components/FsUploader.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAE1D,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAC9C,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAA;AAEjC,kFAAkF;AAClF,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,GAAG,OAAO,EACX,EAAE,eAAe,+BASjB"}

package/dist/web/components/FsUploader.js

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import { useFsUpload } from "../hooks/useFsUpload.js";
+import { UppyUploader } from "./UppyUploader.js";
+function FsUploader({
+  profile,
+  endpoint,
+  onUploadComplete,
+  onUploadError,
+  ...uiProps
+}) {
+  const { uppy } = useFsUpload({
+    profile,
+    endpoint,
+    onUploadComplete,
+    onUploadError
+  });
+  return /* @__PURE__ */ jsx(UppyUploader, { uppy, ...uiProps });
+}
+export {
+  FsUploader
+};

package/dist/web/components/S3Uploader.d.ts

@@ -0,0 +1,6 @@
+import type { UseS3UploadOptions } from '../hooks/useS3Upload.js';
+import type { UppyUploaderProps } from './UppyUploader.js';
+export type S3UploaderProps = UseS3UploadOptions & Omit<UppyUploaderProps, 'uppy'>;
+/** Direct-to-S3 uploader: `useS3Upload` wired to an Uppy UI. */
+export declare function S3Uploader({ profile, confirm, onUploadComplete, onUploadError, ...uiProps }: S3UploaderProps): import("react").JSX.Element;
+//# sourceMappingURL=S3Uploader.d.ts.map

package/dist/web/components/S3Uploader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"S3Uploader.d.ts","sourceRoot":"","sources":["../../../src/web/components/S3Uploader.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAE1D,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAC9C,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAA;AAEjC,gEAAgE;AAChE,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,OAAO,EACP,gBAAgB,EAChB,aAAa,EACb,GAAG,OAAO,EACX,EAAE,eAAe,+BASjB"}

package/dist/web/components/S3Uploader.js

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import { useS3Upload } from "../hooks/useS3Upload.js";
+import { UppyUploader } from "./UppyUploader.js";
+function S3Uploader({
+  profile,
+  confirm,
+  onUploadComplete,
+  onUploadError,
+  ...uiProps
+}) {
+  const { uppy } = useS3Upload({
+    profile,
+    confirm,
+    onUploadComplete,
+    onUploadError
+  });
+  return /* @__PURE__ */ jsx(UppyUploader, { uppy, ...uiProps });
+}
+export {
+  S3Uploader
+};

package/dist/web/components/UppyUploader.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+import type { CedarUppy } from '../createUppy.js';
+export type UploaderVariant = 'dashboard' | 'drag-drop' | 'file-input';
+export interface UppyUploaderProps {
+    uppy: CedarUppy | null;
+    /**
+     * `dashboard` mounts the full `@uppy/dashboard` UI. `drag-drop` renders
+     * Uppy's headless dropzone with a file list. `file-input` renders a plain
+     * upload button. Defaults to `dashboard`.
+     */
+    variant?: UploaderVariant;
+    /** Options passed to `@uppy/dashboard` for the `dashboard` variant. */
+    dashboardOptions?: Record<string, unknown>;
+    /** Text shown under the dropzone for the `drag-drop` variant. */
+    note?: string;
+    children?: ReactNode;
+}
+/**
+ * Renders an Uppy UI for an instance created by `useS3Upload` or
+ * `useFsUpload`. Renders nothing until the instance exists.
+ */
+export declare function UppyUploader({ uppy, variant, dashboardOptions, note, children, }: UppyUploaderProps): import("react").JSX.Element | null;
+//# sourceMappingURL=UppyUploader.d.ts.map

package/dist/web/components/UppyUploader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UppyUploader.d.ts","sourceRoot":"","sources":["../../../src/web/components/UppyUploader.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAStC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;AAEtE,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IACtB;;;;OAIG;IACH,OAAO,CAAC,EAAE,eAAe,CAAA;IACzB,uEAAuE;IACvE,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC1C,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB;AA4DD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,OAAqB,EACrB,gBAAgB,EAChB,IAAI,EACJ,QAAQ,GACT,EAAE,iBAAiB,sCAsBnB"}

package/dist/web/components/UppyUploader.js

@@ -0,0 +1,72 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import {
+  Dropzone,
+  FilesList,
+  UploadButton,
+  UppyContextProvider
+} from "@uppy/react";
+function DashboardMount({
+  uppy,
+  options
+}) {
+  const ref = useRef(null);
+  useEffect(() => {
+    const target = ref.current;
+    if (!target) {
+      return;
+    }
+    let cancelled = false;
+    import("@uppy/dashboard").then(({ default: Dashboard }) => {
+      if (cancelled) {
+        return;
+      }
+      uppy.use(Dashboard, {
+        inline: true,
+        target,
+        proudlyDisplayPoweredByUppy: false,
+        ...options
+      });
+    }).catch((e) => {
+      if (cancelled) {
+        return;
+      }
+      uppy.emit(
+        "error",
+        e instanceof Error ? e : new Error("Could not load @uppy/dashboard")
+      );
+    });
+    return () => {
+      cancelled = true;
+      const plugin = uppy.getPlugin("Dashboard");
+      if (plugin) {
+        uppy.removePlugin(plugin);
+      }
+    };
+  }, [uppy]);
+  return /* @__PURE__ */ jsx("div", { ref });
+}
+function UppyUploader({
+  uppy,
+  variant = "dashboard",
+  dashboardOptions,
+  note,
+  children
+}) {
+  if (!uppy) {
+    return null;
+  }
+  if (variant === "dashboard") {
+    return /* @__PURE__ */ jsx(DashboardMount, { uppy, options: dashboardOptions });
+  }
+  return /* @__PURE__ */ jsxs(UppyContextProvider, { uppy, children: [
+    variant === "drag-drop" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Dropzone, { note }),
+      /* @__PURE__ */ jsx(FilesList, {})
+    ] }) : /* @__PURE__ */ jsx(UploadButton, {}),
+    children
+  ] });
+}
+export {
+  UppyUploader
+};

package/dist/web/createUppy.d.ts

@@ -0,0 +1,62 @@
+import Uppy from '@uppy/core';
+import type { Meta, UppyFile } from '@uppy/core';
+import type { UploadConstraints } from './graphql.js';
+/** The Uppy instance type every Cedar hook and component works with. */
+export type CedarUppy = Uppy;
+/** A file inside a `CedarUppy` instance. */
+export type CedarUppyFile = UppyFile<Meta, Record<string, never>>;
+export { UPLOAD_TOKEN_HEADER } from '../constants.js';
+/** Route the FS uploader posts to, relative to the api origin. */
+export declare const DEFAULT_FS_UPLOAD_PATH = "/upload/fs";
+export interface BaseUppyOptions {
+    /** Constraints from the upload token, applied as Uppy restrictions. */
+    constraints?: UploadConstraints | null;
+    /** Start uploading as soon as files are added. Defaults to `true`. */
+    autoProceed?: boolean;
+    debug?: boolean;
+}
+/**
+ * One file's `{ url, method, headers }` from the api, plus the id of the
+ * pending `Upload` row it belongs to.
+ */
+export interface PresignedUploadParameters {
+    uploadId: string;
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+}
+export interface S3UppyOptions extends BaseUppyOptions {
+    provider: 's3';
+    /**
+     * Asks the api for a presigned URL for one file. Called once per file
+     * with the file's name, type, and size.
+     */
+    getUploadParameters: (file: CedarUppyFile) => Promise<PresignedUploadParameters>;
+}
+export interface FsUppyOptions extends BaseUppyOptions {
+    provider: 'fs';
+    /** Full URL of the api's `POST {prefix}/fs` route, or a function returning it. */
+    endpoint: string | (() => string);
+    /** The upload token to send. Called per request so a refreshed token is used. */
+    getUploadToken: () => string | null;
+}
+export type CreateUppyOptions = S3UppyOptions | FsUppyOptions;
+/** Response body of the api's `POST {prefix}/fs` route. */
+export interface FsUploadResponseBody {
+    uploads: {
+        id: string;
+        status: string;
+        filename: string;
+    }[];
+}
+/**
+ * Creates an Uppy instance pre-configured for one of Cedar's upload flows.
+ * Direct-to-S3 uploads use `@uppy/aws-s3` with the presigned URLs the api
+ * hands out; FS uploads use `@uppy/xhr-upload` against the api's upload
+ * route. The matching plugin is loaded on demand, so only the one in use
+ * needs to be installed.
+ */
+export declare function createUppy(options: CreateUppyOptions): Promise<CedarUppy>;
+/** Reads the `Upload` id Cedar recorded on a file after it uploaded. */
+export declare function getCedarUploadId(file: CedarUppyFile): string | null;
+//# sourceMappingURL=createUppy.d.ts.map

package/dist/web/createUppy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createUppy.d.ts","sourceRoot":"","sources":["../../src/web/createUppy.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,YAAY,CAAA;AAC7B,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAIhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAErD,wEAAwE;AACxE,MAAM,MAAM,SAAS,GAAG,IAAI,CAAA;AAE5B,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;AAEjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAErD,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,eAAe,CAAA;AAElD,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,WAAW,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;IACtC,sEAAsE;IACtE,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAChC;AAED,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,QAAQ,EAAE,IAAI,CAAA;IACd;;;OAGG;IACH,mBAAmB,EAAE,CACnB,IAAI,EAAE,aAAa,KAChB,OAAO,CAAC,yBAAyB,CAAC,CAAA;CACxC;AAED,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,QAAQ,EAAE,IAAI,CAAA;IACd,kFAAkF;IAClF,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAA;IACjC,iFAAiF;IACjF,cAAc,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;CACpC;AAED,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,aAAa,CAAA;AAE7D,2DAA2D;AAC3D,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC5D;AAcD;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,CAAC,CA2EpB;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAInE"}

package/dist/web/createUppy.js

@@ -0,0 +1,82 @@
+import Uppy from "@uppy/core";
+import { UPLOAD_TOKEN_HEADER } from "../constants.js";
+import { UPLOAD_TOKEN_HEADER as UPLOAD_TOKEN_HEADER2 } from "../constants.js";
+const DEFAULT_FS_UPLOAD_PATH = "/upload/fs";
+function restrictionsFor(constraints) {
+  if (!constraints) {
+    return {};
+  }
+  return {
+    allowedFileTypes: constraints.allowedMimeTypes,
+    maxFileSize: constraints.maxFileSize,
+    maxNumberOfFiles: constraints.maxFiles
+  };
+}
+async function createUppy(options) {
+  const { constraints, autoProceed = true, debug = false } = options;
+  const uppy = new Uppy({
+    autoProceed,
+    debug,
+    restrictions: restrictionsFor(constraints)
+  });
+  if (options.provider === "s3") {
+    const { default: AwsS3 } = await import("@uppy/aws-s3");
+    uppy.use(AwsS3, {
+      shouldUseMultipart: false,
+      // The S3 plugin signs by object key, not by file, so the key is set to
+      // the Uppy file id and the file looked up from it inside `signRequest`.
+      // The server chooses the real object key.
+      generateObjectKey: (file) => file.id,
+      signRequest: async (request) => {
+        if (request.method !== "PUT" || "uploadId" in request) {
+          throw new Error(
+            `Cedar presigned uploads only support single PUT requests, got ${request.method}.`
+          );
+        }
+        const file = uppy.getFile(request.key);
+        if (!file) {
+          throw new Error(`Unknown file '${request.key}'.`);
+        }
+        const params = await options.getUploadParameters(file);
+        uppy.setFileMeta(file.id, { cedarUploadId: params.uploadId });
+        return { url: params.url };
+      }
+    });
+    return uppy;
+  }
+  const { default: XHRUpload } = await import("@uppy/xhr-upload");
+  const { endpoint } = options;
+  uppy.use(XHRUpload, {
+    endpoint: typeof endpoint === "function" ? () => endpoint() : endpoint,
+    method: "POST",
+    formData: true,
+    fieldName: "file",
+    bundle: false,
+    headers: () => {
+      const headers = {};
+      const token = options.getUploadToken();
+      if (token) {
+        headers[UPLOAD_TOKEN_HEADER] = token;
+      }
+      return headers;
+    }
+  });
+  uppy.on("upload-success", (file, response) => {
+    const body = response.body;
+    const id = body?.uploads?.[0]?.id;
+    if (file && id) {
+      uppy.setFileMeta(file.id, { cedarUploadId: id });
+    }
+  });
+  return uppy;
+}
+function getCedarUploadId(file) {
+  const id = file.meta.cedarUploadId;
+  return typeof id === "string" ? id : null;
+}
+export {
+  DEFAULT_FS_UPLOAD_PATH,
+  UPLOAD_TOKEN_HEADER2 as UPLOAD_TOKEN_HEADER,
+  createUppy,
+  getCedarUploadId
+};

package/dist/web/graphql.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Constraints echoed with an upload token. The authoritative copy is inside
+ * the signed token; these are for client-side UX only.
+ */
+export interface UploadConstraints {
+    allowedMimeTypes: string[];
+    maxFileSize: number;
+    maxFiles: number;
+}
+export interface RequestUploadTokenData {
+    requestUploadToken: {
+        token: string;
+        allowedMimeTypes: string[];
+        maxFileSize: string | number;
+        maxFiles: number;
+    };
+}
+export interface RequestUploadTokenVariables {
+    profile: string;
+}
+export declare const REQUEST_UPLOAD_TOKEN: import("@apollo/client").DocumentNode;
+export interface CreatePresignedUploadUrlData {
+    createPresignedUploadUrl: {
+        uploadId: string;
+        url: string;
+        method: string;
+        headers: Record<string, string>;
+    };
+}
+export interface CreatePresignedUploadUrlVariables {
+    input: {
+        filename: string;
+        contentType: string;
+        size: string;
+    };
+}
+export declare const CREATE_PRESIGNED_UPLOAD_URL: import("@apollo/client").DocumentNode;
+export interface ConfirmUploadData {
+    confirmUpload: {
+        id: string;
+        status: string;
+    };
+}
+export interface ConfirmUploadVariables {
+    uploadId: string;
+}
+export declare const CONFIRM_UPLOAD: import("@apollo/client").DocumentNode;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/web/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/web/graphql.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,kBAAkB,EAAE;QAClB,KAAK,EAAE,MAAM,CAAA;QACb,gBAAgB,EAAE,MAAM,EAAE,CAAA;QAC1B,WAAW,EAAE,MAAM,GAAG,MAAM,CAAA;QAC5B,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;CACF;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,eAAO,MAAM,oBAAoB,uCAShC,CAAA;AAED,MAAM,WAAW,4BAA4B;IAC3C,wBAAwB,EAAE;QACxB,QAAQ,EAAE,MAAM,CAAA;QAChB,GAAG,EAAE,MAAM,CAAA;QACX,MAAM,EAAE,MAAM,CAAA;QACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAChC,CAAA;CACF;AAED,MAAM,WAAW,iCAAiC;IAChD,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,CAAA;QAChB,WAAW,EAAE,MAAM,CAAA;QACnB,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;CACF;AAED,eAAO,MAAM,2BAA2B,uCAWvC,CAAA;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE;QACb,EAAE,EAAE,MAAM,CAAA;QACV,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,cAAc,uCAO1B,CAAA"}

package/dist/web/graphql.js

@@ -0,0 +1,36 @@
+import { gql } from "@apollo/client";
+const REQUEST_UPLOAD_TOKEN = gql`
+  query CedarRequestUploadToken($profile: String!) {
+    requestUploadToken(profile: $profile) {
+      token
+      allowedMimeTypes
+      maxFileSize
+      maxFiles
+    }
+  }
+`;
+const CREATE_PRESIGNED_UPLOAD_URL = gql`
+  mutation CedarCreatePresignedUploadUrl(
+    $input: CreatePresignedUploadUrlInput!
+  ) {
+    createPresignedUploadUrl(input: $input) {
+      uploadId
+      url
+      method
+      headers
+    }
+  }
+`;
+const CONFIRM_UPLOAD = gql`
+  mutation CedarConfirmUpload($uploadId: String!) {
+    confirmUpload(uploadId: $uploadId) {
+      id
+      status
+    }
+  }
+`;
+export {
+  CONFIRM_UPLOAD,
+  CREATE_PRESIGNED_UPLOAD_URL,
+  REQUEST_UPLOAD_TOKEN
+};

package/dist/web/hooks/useDbUpload.d.ts

@@ -0,0 +1,31 @@
+export interface DbUploadFile {
+    filename: string;
+    mimeType: string;
+    /** Base64-encoded bytes. */
+    data: string;
+    size: number;
+}
+export interface UseDbUploadOptions {
+    allowedMimeTypes: string[];
+    maxFileSize: number;
+    maxFiles?: number;
+    onFileReady?: (file: DbUploadFile) => void;
+}
+export interface UseDbUploadResult {
+    /** Reads one `File` as base64, validating type and size first. */
+    readFile: (file: File) => Promise<DbUploadFile>;
+    /** Reads every file of a `FileList`, validating the count first. */
+    readFiles: (files: FileList | File[]) => Promise<DbUploadFile[]>;
+    progress: {
+        completed: number;
+        total: number;
+    };
+    isReading: boolean;
+}
+/**
+ * Reads small files as base64 for the DB upload path, which sends bytes
+ * through a GraphQL mutation to `storeFile()`. No Uppy involved. The checks
+ * here are UX only; the service enforces the real limits.
+ */
+export declare function useDbUpload({ allowedMimeTypes, maxFileSize, maxFiles, onFileReady, }: UseDbUploadOptions): UseDbUploadResult;
+//# sourceMappingURL=useDbUpload.d.ts.map

package/dist/web/hooks/useDbUpload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDbUpload.d.ts","sourceRoot":"","sources":["../../../src/web/hooks/useDbUpload.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAA;CAC3C;AAED,MAAM,WAAW,iBAAiB;IAChC,kEAAkE;IAClE,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,YAAY,CAAC,CAAA;IAC/C,oEAAoE;IACpE,SAAS,EAAE,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,EAAE,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;IAChE,QAAQ,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9C,SAAS,EAAE,OAAO,CAAA;CACnB;AAkCD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAC1B,gBAAgB,EAChB,WAAW,EACX,QAAQ,EACR,WAAW,GACZ,EAAE,kBAAkB,GAAG,iBAAiB,CA0DxC"}

package/dist/web/hooks/useDbUpload.js

@@ -0,0 +1,80 @@
+import { useCallback, useState } from "react";
+function mimeTypeAllowed(allowed, mimeType) {
+  const normalized = mimeType.toLowerCase();
+  return allowed.some((entry) => {
+    const pattern = entry.toLowerCase();
+    if (pattern === "*/*") {
+      return true;
+    }
+    if (pattern.endsWith("/*")) {
+      return normalized.startsWith(pattern.slice(0, -1));
+    }
+    return pattern === normalized;
+  });
+}
+function readAsBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error("Read failed"));
+    reader.onload = () => {
+      const result = String(reader.result);
+      resolve(result.slice(result.indexOf(",") + 1));
+    };
+    reader.readAsDataURL(file);
+  });
+}
+function useDbUpload({
+  allowedMimeTypes,
+  maxFileSize,
+  maxFiles,
+  onFileReady
+}) {
+  const [progress, setProgress] = useState({ completed: 0, total: 0 });
+  const [isReading, setIsReading] = useState(false);
+  const readFile = useCallback(
+    async (file) => {
+      if (!mimeTypeAllowed(allowedMimeTypes, file.type)) {
+        throw new Error(`File type '${file.type}' is not allowed.`);
+      }
+      if (file.size > maxFileSize) {
+        throw new Error(
+          `File is ${file.size} bytes, which exceeds the ${maxFileSize} byte limit.`
+        );
+      }
+      const result = {
+        filename: file.name,
+        mimeType: file.type,
+        data: await readAsBase64(file),
+        size: file.size
+      };
+      onFileReady?.(result);
+      return result;
+    },
+    [allowedMimeTypes, maxFileSize, onFileReady]
+  );
+  const readFiles = useCallback(
+    async (files) => {
+      const list = Array.from(files);
+      if (maxFiles !== void 0 && list.length > maxFiles) {
+        throw new Error(`At most ${maxFiles} file(s) can be selected.`);
+      }
+      setIsReading(true);
+      setProgress({ completed: 0, total: list.length });
+      try {
+        const results = [];
+        for (const file of list) {
+          results.push(await readFile(file));
+          setProgress({ completed: results.length, total: list.length });
+        }
+        return results;
+      } finally {
+        setIsReading(false);
+      }
+    },
+    [maxFiles, readFile]
+  );
+  return { readFile, readFiles, progress, isReading };
+}
+export {
+  useDbUpload
+};

package/dist/web/hooks/useFsUpload.d.ts

@@ -0,0 +1,20 @@
+import type { UppyUploadCallbacks, UppyUploadResult } from './useUppyUpload.js';
+export interface UseFsUploadOptions extends UppyUploadCallbacks {
+    /** Name of a server-defined upload profile. */
+    profile: string;
+    /**
+     * Full URL of the api's upload route. Defaults to the api URL from
+     * `RWJS_API_URL` plus `/upload/fs`. Read on every request, so it may
+     * change after mount.
+     */
+    endpoint?: string;
+}
+export type UseFsUploadResult = UppyUploadResult & {
+    requestToken: () => Promise<string>;
+};
+/**
+ * Uploads through the api server to an FS target: fetches an upload token
+ * and posts each file to `POST {prefix}/fs` with `@uppy/xhr-upload`.
+ */
+export declare function useFsUpload({ profile, endpoint, onUploadComplete, onUploadError, }: UseFsUploadOptions): UseFsUploadResult;
+//# sourceMappingURL=useFsUpload.d.ts.map

package/dist/web/hooks/useFsUpload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFsUpload.d.ts","sourceRoot":"","sources":["../../../src/web/hooks/useFsUpload.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE/E,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG;IACjD,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACpC,CAAA;AAWD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,aAAa,GACd,EAAE,kBAAkB,GAAG,iBAAiB,CAyDxC"}