@lotics/ui 29.2.0 → 29.3.0

package/docs/catalog.md

@@ -1328,7 +1328,13 @@ source (`src/<module>.tsx`/`.ts`) is the API reference.
 
 - **`mime`** — pure MIME predicates: `isImageMimeType` / `isVideoMimeType` /
   `isAudioMimeType` / `isPdfMimeType` / `isExcelMimeType` / `isCsvMimeType` /
-  `isDocxMimeType` / `isPreviewableMimeType`.
+  `isDocxMimeType` / `isPreviewableMimeType`. Plus
+  **`resolveMimeType(declaredType, filename)`** — what to TREAT a file as. An
+  honestly-declared type is returned untouched; an *uninformative* one (`""`,
+  `application/octet-stream` and friends — what an OS clipboard or drag hands
+  over) is resolved from the filename extension instead, falling back to the
+  declaration when the extension is unknown too. It returns the same answer the
+  server stores, so a surface that filters on it agrees with what gets persisted.
 - **`download`** — `downloadFileFromUrl(url, filename, { credentials? })`: fetch+blob+anchor
   download that works inside sandboxed iframes (where `window.open` is silently dropped);
   `credentials` defaults to `same-origin` — pass `"include"` only for auth-gated same-site

package/docs/data_entry.md

@@ -581,6 +581,19 @@ intake paths, all wired to ONE handler:
    modal dialog with no wrapper). Scope it with `enabled` ("while this record/dialog is open");
    a paste with no acceptable file is left alone, so Ctrl+V in a text field still pastes text.
 
+**What `accept` is matched against, and the one thing a paste cannot do.** A pattern is an
+extension (`.pdf`), a wildcard type (`image/*`) or an exact MIME. A file is matched on
+`resolveMimeType(file.type, file.name)` — its own declared type when that type says something,
+and what its EXTENSION says when it doesn't. That fallback is not a nicety: a file copied in
+Finder/Explorer and pasted arrives with real bytes and a real filename but an uninformative
+type — `""`, or just as often `application/octet-stream`, the same non-answer wearing the shape
+of one. Judging it on that reads silence as "not a PDF", the file is discarded, and since an
+unacceptable paste is deliberately left alone, the user sees nothing happen at all. Matching on
+the resolved type also means the surface agrees with what the server will store. Separately,
+some clipboards carry only a file *reference* (a path/URL, no bytes): there is nothing to
+upload and no API that can go read it, so those pastes cannot work by any means — dragging the
+file is the path that always does.
+
 **Paste routing (focus, then stack).** When two file targets are enabled on the same layer,
 the paste goes to the TOP-MOST one whose `region` contains focus (`document.activeElement`) —
 so two peer file sections each win while the user is working in them, never "last-mounted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/ui",
-  "version": "29.2.0",
+  "version": "29.3.0",
   "type": "module",
   "exports": {
     "./vite": {
@@ -324,6 +324,7 @@
     "test": "vitest run"
   },
   "devDependencies": {
+    "@lotics/shared": "*",
     "@types/react-dom": "~19.2.2",
     "@vitejs/plugin-react": "^4.3.4",
     "lucide-react": "^0.562.0",

package/src/file_intake.ts

@@ -13,11 +13,13 @@
 
 import type { ReactNode } from "react";
 import type { StyleProp, ViewStyle } from "react-native";
+import { resolveMimeType } from "./mime";
 
 /** The filter every intake path applies to what arrived. */
 export interface FileIntakeFilter {
   /** Native `accept` filter (e.g. `"application/pdf,image/*"`) — matched against
-   *  the file's MIME type, or its extension for a `.ext` pattern. */
+   *  the file's MIME type (falling back to what its extension says when the file
+   *  declares none), or against its filename for a `.ext` pattern. */
   accept?: string;
   /** Keep more than one file. Default true. */
   multiple?: boolean;
@@ -79,15 +81,28 @@ export interface FileDropTargetProps extends FileIntakeFilter {
  * Does a file pass a native `accept` list? Each comma-separated pattern is an
  * extension (`.pdf`), a wildcard type (`image/*`) or an exact MIME
  * (`application/pdf`); an empty/absent list accepts everything.
+ *
+ * A file whose declared type says NOTHING is judged by its extension instead.
+ * The OS clipboard is the case that forces this: copy a file in
+ * Finder/Explorer and paste it, and the browser hands over real bytes and a
+ * real filename while declaring `""` — or, just as often,
+ * `application/octet-stream`, the same non-answer wearing the shape of one.
+ * Reading either as a MIME mismatch asserts "this is not a PDF" from data that
+ * never said so, and the file is dropped; because a paste carrying nothing
+ * acceptable is deliberately left alone, that drop is invisible.
+ *
+ * `resolveMimeType` owns which declarations count as uninformative, so this
+ * matches on the same type the SERVER will store for the file.
  */
 export function matchesAccept(file: File, accept: string | undefined): boolean {
   if (!accept) return true;
   const patterns = accept.split(",").map((p) => p.trim().toLowerCase()).filter(Boolean);
   if (patterns.length === 0) return true;
-  const mime = file.type.toLowerCase();
   const name = file.name.toLowerCase();
+  const mime = resolveMimeType(file.type, name);
   return patterns.some((p) => {
     if (p.startsWith(".")) return name.endsWith(p);
+    if (!mime) return false;
     if (p.endsWith("/*")) return mime.startsWith(p.slice(0, -1));
     return mime === p;
   });

package/src/mime.ts

@@ -52,3 +52,79 @@ export function isPreviewableMimeType(mimeType: string): boolean {
     isDocxMimeType(mimeType)
   );
 }
+
+/** A MIME type without its parameters (`text/csv; charset=utf-8` → `text/csv`). */
+function normalizeMimeType(mimeType: string): string {
+  return mimeType.split(";")[0]!.trim().toLowerCase();
+}
+
+/**
+ * Types that carry no information — a sender that declined to classify the
+ * bytes. The empty string is only the most obvious one: an OS clipboard or drag
+ * routinely hands a file over as `application/octet-stream` instead, which is
+ * the same statement made in a way that LOOKS like an answer.
+ */
+const GENERIC_MIME_TYPES: ReadonlySet<string> = new Set([
+  "",
+  "application/octet-stream",
+  "binary/octet-stream",
+  "application/binary",
+  "application/unknown",
+]);
+
+/**
+ * Extension → MIME, for the document and image formats an intake surface names.
+ * A `Map`, not an object literal, so a file named `x.constructor` looks up a
+ * miss rather than `Object.prototype`'s member.
+ */
+const MIME_BY_EXTENSION: ReadonlyMap<string, string> = new Map([
+  ["pdf", "application/pdf"],
+  ["png", "image/png"],
+  ["jpg", "image/jpeg"],
+  ["jpeg", "image/jpeg"],
+  ["gif", "image/gif"],
+  ["webp", "image/webp"],
+  ["avif", "image/avif"],
+  ["bmp", "image/bmp"],
+  ["svg", "image/svg+xml"],
+  ["tif", "image/tiff"],
+  ["tiff", "image/tiff"],
+  ["heic", "image/heic"],
+  ["heif", "image/heif"],
+  ["csv", "text/csv"],
+  ["tsv", "text/tab-separated-values"],
+  ["txt", "text/plain"],
+  ["xml", "application/xml"],
+  ["json", "application/json"],
+  ["zip", "application/zip"],
+  ["xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
+  ["xls", "application/vnd.ms-excel"],
+  ["docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+  ["doc", "application/msword"],
+]);
+
+/** What a filename's extension says the file is, or `""` when it says nothing. */
+function mimeTypeFromFileName(name: string): string {
+  const dot = name.lastIndexOf(".");
+  // `dot <= 0` also rejects a dotfile (`.pdf` is a NAME, not an extension);
+  // `length - 1` rejects a trailing dot.
+  if (dot <= 0 || dot === name.length - 1) return "";
+  return MIME_BY_EXTENSION.get(name.slice(dot + 1).toLowerCase()) ?? "";
+}
+
+/**
+ * The type to TREAT content as, given what its sender declared and what it is
+ * called. An honestly-declared type is never second-guessed — only an
+ * uninformative one is resolved, and only from the filename, falling back to
+ * the declaration when the extension is unrecognized too.
+ *
+ * Mirrors `resolveMimeType` in `@lotics/shared/file_type`, which is what the
+ * server stores. The kit cannot import it (`primitives_purity.test.ts` keeps
+ * `src/` free of `@lotics/shared`), so `mime_parity.test.ts` asserts the two
+ * agree instead of trusting that they will.
+ */
+export function resolveMimeType(declaredMimeType: string, filename: string): string {
+  const declared = normalizeMimeType(declaredMimeType);
+  if (!GENERIC_MIME_TYPES.has(declared)) return declared;
+  return mimeTypeFromFileName(filename) || declared;
+}