Files
clean-architecture-frontend…/src/adapters/browser-files/create-browser-file-runtime.ts
T
DongHyeonkaandClaude Opus 5.5 042427c887 refactor(browser-files): share the media-type, token and limit checks (Q-6.2-12)
The exact media-type regex lived in object-url-lease.ts,
browser-file-policy-registry.ts and the download validation;
safeOpaqueValue (vault) and safeGeneratedToken (download) were the same
regex; and five modules each defined their own positive-safe-integer check
(isPositiveByteLimit included). file-policy.ts now exports one copy of each:
EXACT_MEDIA_TYPE, isSafeGeneratedToken, isPositiveSafeInteger.
ObjectUrlLeaseRegistry.create also loses an inner revoke branch that could
never run (it required a non-empty string inside a "not a non-empty string"
guard).

cache-storage/public-cache-policy.ts keeps its private positiveSafeInteger:
adapters may not import another adapter's module.

Verified: a characterization test (unsafe reference -> UNAVAILABLE, 128-char
token accepted, empty object URL -> no revoke, fractional/zero limits and a
wildcard download media type rejected) passes on the code before and after.
Lane gates pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 13:39:59 +09:00

243 lines
7.4 KiB
TypeScript

import type {
DownloadDeliveryPort,
FileContentPort,
FilePickerPort,
TransientPreviewPort,
} from "../../application/ports/browser-file-storage/file.ts";
import {
EnhancedFilePicker,
NativeInputFilePicker,
type NativeInputFilePickerOptions,
type SystemOpenPicker,
} from "./browser-file-picker.ts";
import {
BrowserFileVault,
DEFAULT_MAX_INSPECTION_BYTES,
type BrowserFileVaultOptions,
} from "./browser-file-vault.ts";
import {
BrowserFilePolicyRegistry,
type BrowserFilePolicyProfile,
} from "./browser-file-policy-registry.ts";
import {
createDownloadDeliveryAdapter,
type DownloadDeliveryAdapterOptions,
} from "./download-delivery-adapter.ts";
import type { BrowserFileObserver } from "./file-observer.ts";
import { isPositiveSafeInteger } from "./file-policy.ts";
import {
BrowserTransientPreview,
ObjectUrlLeaseRegistry,
type ObjectUrlApi,
} from "./object-url-lease.ts";
type UserActivationState = Readonly<{ isActive: boolean }>;
export type BrowserFileRuntimeOptions = Readonly<{
input: HTMLInputElement;
policies: readonly BrowserFilePolicyProfile[];
limits: Readonly<{
hardMaxPreviewBytes: number;
hardMaxObjectUrlBytes: number;
hardMaxTransferBytes: number;
hardMaxActiveFileReferences?: number;
hardMaxRetainedFileBytes?: number;
hardMaxActiveObjectUrls?: number;
hardMaxObjectUrlAggregateBytes?: number;
}>;
download: Omit<
DownloadDeliveryAdapterOptions,
| "objectUrls"
| "observer"
| "policies"
| "userActivation"
| "hardMaxObjectUrlBytes"
| "hardMaxTransferBytes"
>;
showOpenFilePicker?: SystemOpenPicker;
userActivation?: UserActivationState;
observer?: BrowserFileObserver;
objectUrlApi?: ObjectUrlApi;
vault?: Omit<BrowserFileVaultOptions, "observer" | "policies">;
nativePicker?: Pick<
NativeInputFilePickerOptions,
| "window"
| "scheduler"
| "focusFallbackGraceMs"
| "cancelFallbackDelayMs"
>;
hardForbiddenPreviewMediaTypes?: ReadonlySet<string>;
}>;
export type BrowserFileRuntime = Readonly<{
/**
* Canonical cross-browser control. Presentation decides which explicit
* user action invokes this baseline.
*/
baselinePicker: FilePickerPort;
/**
* Optional enhancement. It is never retried through baselinePicker in the
* same user activation.
*/
enhancedPicker: FilePickerPort | null;
content: FileContentPort;
previews: TransientPreviewPort;
downloads: DownloadDeliveryPort;
dispose(): void;
}>;
/**
* Optional feature factory. Nothing imports this from bootstrap, so browser
* file code remains outside the default bundle until a feature composes it.
*/
export function createBrowserFileRuntime(
options: BrowserFileRuntimeOptions,
): BrowserFileRuntime {
const limits = resolveRuntimeLimits(options.limits);
const policies = new BrowserFilePolicyRegistry({
profiles: options.policies,
hardLimits: {
maxInspectionBytes:
options.vault?.hardMaxInspectionBytes ??
DEFAULT_MAX_INSPECTION_BYTES,
maxRetainedFileBytes: limits.hardMaxRetainedFileBytes,
maxPreviewBytes: limits.hardMaxPreviewBytes,
maxObjectUrlBytes: limits.hardMaxObjectUrlBytes,
maxTransferBytes: limits.hardMaxTransferBytes,
},
});
const objectUrls = new ObjectUrlLeaseRegistry(
options.objectUrlApi,
{
hardMaxActiveLeases: limits.hardMaxActiveObjectUrls,
hardMaxSingleLeaseBytes: Math.max(
limits.hardMaxPreviewBytes,
limits.hardMaxObjectUrlBytes,
),
hardMaxAggregateLeaseBytes:
limits.hardMaxObjectUrlAggregateBytes,
},
);
const vault = new BrowserFileVault({
...options.vault,
policies,
hardMaxActiveReferences: limits.hardMaxActiveFileReferences,
hardMaxRetainedBytes: limits.hardMaxRetainedFileBytes,
observer: options.observer,
});
const commonPickerOptions = {
vault,
policies,
userActivation: options.userActivation,
observer: options.observer,
};
const baselinePicker = new NativeInputFilePicker({
...commonPickerOptions,
...options.nativePicker,
input: options.input,
systemOpenPickerSupported:
options.showOpenFilePicker !== undefined,
systemSavePickerSupported:
options.download.showSaveFilePicker !== undefined,
});
const enhancedPicker = options.showOpenFilePicker
? new EnhancedFilePicker({
...commonPickerOptions,
showOpenFilePicker: options.showOpenFilePicker,
systemSavePickerSupported:
options.download.showSaveFilePicker !== undefined,
})
: null;
const previews = new BrowserTransientPreview({
files: vault,
policies,
leases: objectUrls,
hardMaxPreviewBytes: limits.hardMaxPreviewBytes,
hardForbiddenMediaTypes:
options.hardForbiddenPreviewMediaTypes,
observer: options.observer,
});
const downloads = createDownloadDeliveryAdapter({
...options.download,
policies,
objectUrls,
hardMaxObjectUrlBytes: limits.hardMaxObjectUrlBytes,
hardMaxTransferBytes: limits.hardMaxTransferBytes,
observer: options.observer,
userActivation: options.userActivation,
});
let disposed = false;
return Object.freeze({
baselinePicker,
enhancedPicker,
content: vault,
previews,
downloads,
dispose(): void {
if (disposed) return;
disposed = true;
baselinePicker.dispose();
enhancedPicker?.dispose();
downloads.dispose();
previews.dispose();
vault.dispose();
},
});
}
type ResolvedRuntimeLimits = Readonly<{
hardMaxPreviewBytes: number;
hardMaxObjectUrlBytes: number;
hardMaxTransferBytes: number;
hardMaxActiveFileReferences: number;
hardMaxRetainedFileBytes: number;
hardMaxActiveObjectUrls: number;
hardMaxObjectUrlAggregateBytes: number;
}>;
function resolveRuntimeLimits(
limits: BrowserFileRuntimeOptions["limits"],
): ResolvedRuntimeLimits {
const hardMaxSingleObjectUrlBytes = Math.max(
limits.hardMaxPreviewBytes,
limits.hardMaxObjectUrlBytes,
);
const derivedAggregate = Math.min(
Number.MAX_SAFE_INTEGER,
hardMaxSingleObjectUrlBytes * 4,
);
const resolved = Object.freeze({
hardMaxPreviewBytes: limits.hardMaxPreviewBytes,
hardMaxObjectUrlBytes: limits.hardMaxObjectUrlBytes,
hardMaxTransferBytes: limits.hardMaxTransferBytes,
hardMaxActiveFileReferences:
limits.hardMaxActiveFileReferences ?? 32,
hardMaxRetainedFileBytes:
limits.hardMaxRetainedFileBytes ??
limits.hardMaxTransferBytes,
hardMaxActiveObjectUrls:
limits.hardMaxActiveObjectUrls ?? 16,
hardMaxObjectUrlAggregateBytes:
limits.hardMaxObjectUrlAggregateBytes ?? derivedAggregate,
});
if (
!isPositiveSafeInteger(resolved.hardMaxPreviewBytes) ||
!isPositiveSafeInteger(resolved.hardMaxObjectUrlBytes) ||
!isPositiveSafeInteger(resolved.hardMaxTransferBytes) ||
!isPositiveSafeInteger(resolved.hardMaxActiveFileReferences) ||
!isPositiveSafeInteger(resolved.hardMaxRetainedFileBytes) ||
!isPositiveSafeInteger(resolved.hardMaxActiveObjectUrls) ||
!isPositiveSafeInteger(resolved.hardMaxObjectUrlAggregateBytes) ||
resolved.hardMaxObjectUrlBytes >
resolved.hardMaxTransferBytes ||
resolved.hardMaxPreviewBytes >
resolved.hardMaxRetainedFileBytes ||
hardMaxSingleObjectUrlBytes >
resolved.hardMaxObjectUrlAggregateBytes
) {
throw new TypeError("Browser file runtime hard limits are invalid.");
}
return resolved;
}