@remotion/browser-bundler 4.0.527

package/dist/create-browser-bundle-runtime.d.ts

@@ -0,0 +1,7 @@
+import type { FC } from 'react';
+import type { BrowserBundle } from './types';
+export type BrowserBundleRuntime = {
+    applyBundle: (bundle: BrowserBundle) => Promise<FC>;
+    dispose: () => void;
+};
+export declare const createBrowserBundleRuntime: () => BrowserBundleRuntime;

package/dist/create-browser-bundler.d.ts

@@ -0,0 +1,2 @@
+import type { BrowserBundler, BrowserBundlerOptions } from './types';
+export declare const createBrowserBundler: (options?: BrowserBundlerOptions) => BrowserBundler;

package/dist/create-browser-compiler.d.ts

@@ -0,0 +1,27 @@
+import type * as RspackBrowser from '@rspack/browser';
+import type { BrowserBundlerProgress, VirtualProject } from './types';
+export type BrowserCompilerProject = VirtualProject & {
+    rootDir: string;
+};
+export type BrowserCompilerResult = {
+    bundle: string | null;
+    assets: {
+        name: string;
+        content: string;
+    }[];
+    errors: string[];
+    warnings: string[];
+    hash: string | undefined;
+    modules: Record<string, string>;
+    time: number | undefined;
+};
+export type BrowserCompiler = {
+    compile: (project: BrowserCompilerProject) => Promise<BrowserCompilerResult>;
+    dispose: () => Promise<void>;
+};
+export declare const createBrowserCompiler: ({ project, virtualFiles, configure, onProgress, }: {
+    project: BrowserCompilerProject;
+    virtualFiles: Record<string, string>;
+    configure: (rspack: typeof RspackBrowser) => RspackBrowser.RspackOptions;
+    onProgress: ((progress: BrowserBundlerProgress) => void) | null;
+}) => Promise<BrowserCompiler>;

package/dist/create-browser-composition-observer.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { BrowserComposition } from './get-browser-composition';
+export type BrowserCompositionSelection = {
+    readonly root: React.FC;
+    readonly compositionId: string;
+    readonly inputProps: Record<string, unknown>;
+};
+export type BrowserCompositionObserver = {
+    update: (selection: BrowserCompositionSelection) => void;
+    dispose: () => void;
+};
+export declare const createBrowserCompositionObserver: ({ onChange, onError, }: {
+    onChange: (composition: BrowserComposition) => void;
+    onError: (error: Error) => void;
+}) => BrowserCompositionObserver;

package/dist/dependency-resolution.d.ts

@@ -0,0 +1,9 @@
+import type * as RspackBrowser from '@rspack/browser';
+export declare const createBrowserDependencyPlugin: ({ rspack, resolvedUrls, resolvedVersions, resolvePackage, external, development, }: {
+    rspack: typeof RspackBrowser;
+    resolvedUrls: Record<string, string>;
+    resolvedVersions: Record<string, string>;
+    resolvePackage: ((request: string) => string | null) | null;
+    external: string[];
+    development: boolean;
+}) => RspackBrowser.BrowserHttpImportEsmPlugin;

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+import type { SerializedCompilerError } from './types';
+export declare class BrowserBundlerError extends Error {
+    readonly diagnostics: string[];
+    constructor(message: string, diagnostics: string[]);
+}
+export declare const serializeCompilerError: (error: unknown) => SerializedCompilerError;

package/dist/fast-refresh-bridge.d.ts

@@ -0,0 +1,8 @@
+export declare const browserBundleHmrBridgeName = "remotion_browserBundlerHmr";
+export declare const browserBundleHotUpdateName = "remotion_browserBundlerHotUpdate";
+export type BrowserBundleHotRuntime = {
+    check: () => Promise<(string | number)[] | null>;
+    apply: () => Promise<(string | number)[]>;
+    getHash: () => string;
+    status: () => string;
+};

package/dist/get-browser-composition.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { AnyComposition, VideoConfig } from 'remotion';
+export type BrowserComposition = VideoConfig & {
+    component: AnyComposition['component'];
+};
+/**
+ * Mounts a registered Root to select a Composition and resolve its metadata.
+ * Input props override default props. Root providers are used for registration
+ * only; they are not included around the component returned for the Player.
+ * Pass an AbortSignal to cancel pending lazy roots or calculateMetadata().
+ */
+export declare const getBrowserComposition: ({ root: RegisteredRoot, compositionId, inputProps, signal, }: {
+    root: React.FC<{}>;
+    compositionId: string;
+    inputProps: Record<string, unknown>;
+    signal?: AbortSignal | undefined;
+}) => Promise<BrowserComposition>;

package/dist/hmr-assets.d.ts

@@ -0,0 +1,16 @@
+export type BrowserHmrAsset = {
+    name: string;
+    content: string;
+};
+export type BrowserHmrBridge = {
+    getManifest: (name: string) => Promise<object | undefined>;
+    resolveScriptUrl: (name: string) => string;
+};
+export declare const createBrowserHmrAssetManager: ({ createObjectUrl, revokeObjectUrl, }: {
+    createObjectUrl: (blob: Blob) => string;
+    revokeObjectUrl: (url: string) => void;
+}) => {
+    bridge: BrowserHmrBridge;
+    dispose: () => void;
+    updateAssets: (newAssets: BrowserHmrAsset[]) => void;
+};

package/dist/hmr-plugins.d.ts

@@ -0,0 +1,10 @@
+import type * as RspackBrowser from '@rspack/browser';
+export declare const createBrowserReactRefreshPlugin: ({ rspack, refreshRuntime, refreshUtils, }: {
+    rspack: typeof RspackBrowser;
+    refreshRuntime: string;
+    refreshUtils: string;
+}) => RspackBrowser.RspackPluginInstance;
+export declare const createBrowserHmrRuntimePlugin: ({ rspack, bridgeName, }: {
+    rspack: typeof RspackBrowser;
+    bridgeName: string;
+}) => RspackBrowser.RspackPluginInstance;

package/dist/http-client.d.ts

@@ -0,0 +1,9 @@
+type BrowserHttpResponse = {
+    body: Buffer;
+    headers: Record<string, string>;
+    status: number;
+};
+export declare const makeBrowserHttpClient: ({ fetchImplementation, }: {
+    fetchImplementation: (input: URL | RequestInfo, init?: RequestInit | undefined) => Promise<Response>;
+}) => (url: string, headers: Record<string, string>) => Promise<BrowserHttpResponse>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createBrowserBundler } from './create-browser-bundler';
+export { BrowserBundlerError } from './errors';
+export type { BrowserBundle, BrowserBundler, BrowserBundlerOptions, BrowserBundlerProgress, VirtualFileSystem, VirtualProject, } from './types';

package/dist/index.js

@@ -0,0 +1,115 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/errors.ts
+class BrowserBundlerError extends Error {
+  diagnostics;
+  constructor(message, diagnostics) {
+    super(message);
+    this.name = "BrowserBundlerError";
+    this.diagnostics = diagnostics;
+  }
+}
+
+// src/create-browser-bundler.ts
+var createBrowserBundler = (options = {}) => {
+  if (typeof Worker === "undefined") {
+    throw new Error("createBrowserBundler() must be called in a browser.");
+  }
+  if (!globalThis.crossOriginIsolated) {
+    throw new Error("The browser bundler requires cross-origin isolation. Serve the page with Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp.");
+  }
+  const worker = options.workerUrl ? new Worker(options.workerUrl, { type: "module" }) : new Worker(new URL("./browser-bundler-worker.js", import.meta.url), {
+    type: "module"
+  });
+  const dependencyVersions = { ...options.dependencyVersions };
+  const enableFastRefresh = options.enableFastRefresh ?? false;
+  const pending = new Map;
+  let nextId = 0;
+  let terminalError = null;
+  const stop = (error) => {
+    terminalError = error;
+    worker.terminate();
+    for (const request of pending.values()) {
+      request.reject(error);
+    }
+    pending.clear();
+  };
+  worker.onmessage = (event) => {
+    const response = event.data;
+    if (response.type === "progress") {
+      options.onProgress?.(response);
+      return;
+    }
+    const request = pending.get(response.id);
+    if (!request) {
+      return;
+    }
+    pending.delete(response.id);
+    if (response.type === "error") {
+      const error = new BrowserBundlerError(response.error.message, response.error.diagnostics);
+      if (response.error.stack) {
+        error.stack = response.error.stack;
+      }
+      request.reject(error);
+      return;
+    }
+    request.resolve(response.bundle);
+  };
+  worker.onerror = (event) => {
+    stop(new Error(event.message || "The browser compiler worker failed."));
+  };
+  worker.onmessageerror = () => {
+    stop(new Error("Could not read the browser compiler worker response."));
+  };
+  return {
+    bundle: ({ project }) => {
+      if (terminalError) {
+        return Promise.reject(terminalError);
+      }
+      const id = nextId++;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        try {
+          worker.postMessage({
+            id,
+            project,
+            dependencyVersions,
+            enableFastRefresh
+          });
+        } catch (error) {
+          pending.delete(id);
+          reject(error);
+        }
+      });
+    },
+    dispose: () => {
+      stop(new Error("The browser bundler has been disposed."));
+    }
+  };
+};
+export {
+  createBrowserBundler,
+  BrowserBundlerError
+};

package/dist/index.js.LICENSE.txt

@@ -0,0 +1,19 @@
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+/*! https://mths.be/punycode v1.4.1 by @mathias */
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/dist/load-browser-bundle.d.ts

@@ -0,0 +1,10 @@
+import type { FC } from 'react';
+import type { BrowserBundle } from './types.js';
+/**
+ * Executes a browser bundle and returns its registerRoot() component.
+ * Only execute code you trust: this uses Function(), not a sandbox, and the
+ * bundle has access to the page. React and Remotion are shared with the host.
+ */
+export declare const loadBrowserBundle: ({ bundle }: {
+    bundle: BrowserBundle;
+}) => FC;

package/dist/load-rspack.d.ts

@@ -0,0 +1,3 @@
+import type * as RspackBrowser from '@rspack/browser';
+import type { BrowserBundlerProgress } from './types';
+export declare const loadRspackBrowser: (onProgress: ((progress: BrowserBundlerProgress) => void) | null) => Promise<typeof RspackBrowser>;

package/dist/refresh-virtual-files.d.ts

@@ -0,0 +1,5 @@
+export declare const getBrowserReactRefreshVirtualFiles: ({ entry, runtime, utils, }: {
+    entry: string;
+    runtime: string;
+    utils: string;
+}) => Record<string, string>;

package/dist/runtime.d.ts

@@ -0,0 +1,5 @@
+export { createBrowserBundleRuntime, type BrowserBundleRuntime, } from './create-browser-bundle-runtime';
+export { createBrowserCompositionObserver, type BrowserCompositionObserver, type BrowserCompositionSelection, } from './create-browser-composition-observer';
+export { getBrowserComposition } from './get-browser-composition.js';
+export type { BrowserComposition } from './get-browser-composition.js';
+export { loadBrowserBundle } from './load-browser-bundle.js';