@oeave/bakery3 0.0.0-stage → 0.1.0

package/dist/r3f/index.d.ts

@@ -0,0 +1,159 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, ReactElement } from 'react';
+import { d as CompatibilityReport, Q as QualityPreset } from '../bake-DaOlenyx.js';
+import { C as CostEstimate, u as RenderResult, v as TokenProvider } from '../testRun-BIPXaVPb.js';
+export { c as Bakery3Error, w as RenderBudgetExceeded } from '../testRun-BIPXaVPb.js';
+import { Bakery3Options, Bakery3, RenderVideoOptions, RenderJob, EstimateOptions } from '../index.js';
+export { RenderOptions } from '../index.js';
+import { a as TimelineOptions, T as Timeline } from '../timeline-ChwgD7bT.js';
+export { K as Keyframe, b as Track, c as createTimeline } from '../timeline-ChwgD7bT.js';
+import { DevPanelTab, TimelinePanelTarget, BakeTransport, DevPanelHistoryOptions, TimelinePanelOptions } from '../devtools/index.js';
+import '../animation-B1h0Ryvj.js';
+import 'three';
+import '../prepare-C5qVvaw4.js';
+import '../bake/index.js';
+
+/**
+ * Mount INSIDE `<Canvas>`.
+ *
+ * It has to be: `useThree` only resolves against R3F's own store, and the
+ * point of the provider is to hold the live scene and camera. Wrapping
+ * `<Canvas>` with it instead yields an error from `useThree`, not from here.
+ *
+ * The client is rebuilt when `apiKey` or `baseUrl` changes. `token` is read
+ * through a ref, so a token function written inline does not rebuild it.
+ */
+declare function Bakery3Provider({ children, ...options }: Bakery3Options & {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+type UseBakery3 = {
+    /**
+     * One render, watched: `job`, `progress`, `previewUrl` and `result` follow
+     * it. With `cameras` it is a set of pictures instead, handed back as it is:
+     * a set reports through `set.wait({ onProgress })`, not through one job's
+     * state.
+     */
+    render: Bakery3['render'];
+    /** Every variant, from every camera. The provider's live scene is the default. */
+    renderVariants: Bakery3['renderVariants'];
+    /** What that run would cost, with nothing admitted. */
+    quoteVariants: Bakery3['quoteVariants'];
+    /** Three variants, every camera, small and fast: look before paying. */
+    testVariants: Bakery3['testVariants'];
+    /** A render by id, as a job: after a reload, in another tab, from a
+     *  webhook. Needs no canvas. */
+    getRender: Bakery3['getRender'];
+    /** A timeline bound to the provider's live scene and camera. */
+    timeline: (options?: TimelineOptions) => Timeline;
+    /** The same capture as `render`, plus a baked timeline, as a video. */
+    renderVideo: (options: RenderVideoOptions) => Promise<RenderJob>;
+    estimate: (options?: EstimateOptions) => Promise<CostEstimate>;
+    check: () => CompatibilityReport;
+    /**
+     * The latest render or video, once it was accepted. With a provider it is
+     * shared: every `useBakery3()` under it, and the devtools panel, see the
+     * same one, whichever component started it.
+     */
+    job: RenderJob | null;
+    /** True from the call until the latest render settles, whichever way. */
+    isRendering: boolean;
+    /** Available seconds before the final image, on `studio` and `ultra`. */
+    previewUrl: string | undefined;
+    /** 0 to 1. */
+    progress: number;
+    /** The finished render: `result.url` is the image or the video. */
+    result: RenderResult | null;
+    error: Error | null;
+    /**
+     * The client itself. Without options, null outside `<Canvas>` until the
+     * provider inside it has mounted; `ready` says the same thing as a boolean.
+     */
+    bakery3: Bakery3 | null;
+    /** Without options, false until a `<Bakery3Provider>` has mounted. Disable
+     *  a render button on it. */
+    ready: boolean;
+};
+/**
+ * Works on both sides of `<Canvas>`, with or without a provider.
+ *
+ * With options (`{ apiKey }` or `{ token }`) it is a client of its own. Each
+ * call renders the canvas it is inside, or, from the ordinary DOM, the one
+ * canvas on the page; with several it refuses and points at the provider.
+ *
+ * Without options it uses `<Bakery3Provider>`. Inside the provider it reads
+ * React context. Outside, where a render button actually lives (R3F's
+ * reconciler has no `<button>`), it reads the store the provider publishes
+ * to. With two providers on one page, the one that mounted last is the one an
+ * outside caller gets, so call the hook inside the provider when that matters.
+ */
+declare function useBakery3(options?: Bakery3Options): UseBakery3;
+
+type Props = {
+    /**
+     * What the browser renders. Mounted normally. A material element
+     * (`<shaderMaterial>`, `<meshStandardMaterial>`), or a component that
+     * forwards its ref to one: the fallback is written onto the material that
+     * ref reaches. A ref of your own on it still receives the material.
+     */
+    web: ReactNode;
+    /**
+     * What the render shows instead. A `<meshPhysicalMaterial>` element, read
+     * for its props and never mounted.
+     */
+    render: ReactElement<Record<string, unknown>>;
+};
+declare function Bakery3Material({ web, render }: Props): react_jsx_runtime.JSX.Element;
+
+type Bakery3DevtoolsProps = {
+    /**
+     * A client of its own, as `useBakery3({ apiKey })` has: no
+     * `<Bakery3Provider>` needed. The panel shows the page's one `<Canvas>`
+     * (or the one it is inside), waiting for it to mount. Leave out `apiKey`
+     * and `token` to use the provider's client instead.
+     */
+    apiKey?: string;
+    /** A function that mints a browser token, as the provider takes. */
+    token?: TokenProvider;
+    /** With `apiKey` or `token`: the API to talk to. */
+    baseUrl?: string;
+    /** With `apiKey` or `token`: the `fetch` the client uses. */
+    fetch?: typeof fetch;
+    /** With `apiKey` or `token`: defaults folded into every render. */
+    defaults?: Bakery3Options['defaults'];
+    /** Corner to sit in. */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    defaultQuality?: QualityPreset;
+    defaultOpen?: boolean;
+    defaultTab?: DevPanelTab;
+    /**
+     * The timeline the Video tab films. Without one the panel makes its own on
+     * the live scene and camera, empty: frame a shot and press Keyframe camera.
+     */
+    timeline?: Timeline;
+    /** Objects offered in the timeline's "add track" picker. */
+    timelineTargets?: TimelinePanelTarget[];
+    /** Fired when the timeline takes the camera and when it gives it back.
+     *  Suspend your orbit controls here. */
+    onPlaybackChange?: (active: boolean) => void;
+    /** Bake with your own worker instead of the hosted one. */
+    bakeTransport?: BakeTransport;
+    /** Where a bundle's relative uris resolve against, when it has any. */
+    bakeBaseUrl?: string;
+    /** Zero the realtime lights when a generation is applied. Off by default:
+     *  the session already replaces diffuse lighting with the lightmap (see
+     *  bake/shading.ts), so muting only removes the lamps' highlights. It is a
+     *  look to switch on from the panel, not a correction. */
+    muteLightsOnApply?: boolean;
+    history?: DevPanelHistoryOptions;
+};
+declare function Bakery3Devtools(props: Bakery3DevtoolsProps): null;
+
+/** Everything the vanilla panel takes except `container`: the element is
+ *  fixed-positioned and appended to the body, so a React parent choosing where
+ *  it lands in the tree would change nothing except when it unmounts. */
+type Bakery3TimelineProps = Omit<TimelinePanelOptions, 'container'>;
+/** Mounts the devtools timeline panel for as long as this component is
+ *  rendered. Renders nothing itself. */
+declare function Bakery3Timeline(props: Bakery3TimelineProps): null;
+
+export { BakeTransport, Bakery3, Bakery3Devtools, type Bakery3DevtoolsProps, Bakery3Material, Bakery3Options, Bakery3Provider, Bakery3Timeline, type Bakery3TimelineProps, EstimateOptions, RenderVideoOptions, Timeline, TimelineOptions, type UseBakery3, useBakery3 };