motionrender 0.0.0-stage → 0.2.0

package/dist/builder.js

@@ -0,0 +1,169 @@
+// packages/builder/src/index.ts
+var layer = (type, options) => ({ type, ...options });
+var text = (content, options = {}) => layer("text", { content, ...options });
+var rect = (options) => layer("rect", options);
+var circle = (options) => layer("circle", options);
+var path = (d, options = {}) => layer("path", { d, ...options });
+var image = (src, options = {}) => layer("image", { src, ...options });
+var clip = (src, options = {}) => layer("video", { src, ...options });
+var audio = (src, options = {}) => layer("audio", { src, ...options });
+var sfx = (name, options = {}) => layer("audio", { src: `sfx:${name}`, ...options });
+var group = (children, options = {}) => layer("group", { ...options, children });
+var html = (markup, options) => layer("html", { html: markup, ...options });
+var lottie = (src, options) => layer("lottie", { src, ...options });
+var shader = (fragment, options) => layer("shader", { fragment, ...options });
+var captions = (src, options = {}) => layer("captions", { src, ...options });
+var use = (component, values = {}, options = {}) => ({ use: component, ...options, with: values });
+var code = (draw, options) => layer("code", { code: typeof draw === "string" ? draw : `const draw = ${draw.toString()};`, ...options });
+var keyframes = (property, frames, options = {}) => ({ property, keyframes: frames.map(([frame, value, easing]) => easing === void 0 ? { frame, value } : { frame, value, easing }), ...options });
+var tween = (property, from, to, options = {}) => {
+  const frames = options.frames ?? 15, delay = options.delay ?? 0;
+  return keyframes(property, [...delay ? [[0, from]] : [], [delay, from, options.easing], [delay + frames, to]]);
+};
+var fadeIn = (frames = 12, delay = 0) => tween("opacity", 0, 1, { frames, delay });
+var fadeOut = (atFrame, frames = 12) => keyframes("opacity", [[atFrame, 1], [atFrame + frames, 0]]);
+var riseIn = (y, distance = 36, frames = 18, delay = 0) => [tween("y", y + distance, y, { frames, delay, easing: "land" }), fadeIn(Math.round(frames * 0.75), delay)];
+var sample = (property, from, to, fn, options = {}) => {
+  const step = Math.max(1, Math.round(options.step ?? 2)), frames = [];
+  for (let f = from; f < to; f += step) frames.push([f, Math.round(fn(f) * 1e3) / 1e3]);
+  frames.push([to, Math.round(fn(to) * 1e3) / 1e3]);
+  return keyframes(property, frames);
+};
+function spring(options) {
+  const { fps = 30, damping = 10, stiffness = 100, mass = 1, from = 0, to = 1 } = options, t = Math.max(0, options.frame) / fps, w0 = Math.sqrt(stiffness / mass), z = damping / (2 * Math.sqrt(stiffness * mass));
+  const wd = w0 * Math.sqrt(Math.max(0, 1 - z * z));
+  const v = z < 1 ? 1 - Math.exp(-z * w0 * t) * (Math.cos(wd * t) + z * w0 / wd * Math.sin(wd * t)) : 1 - Math.exp(-w0 * t) * (1 + w0 * t);
+  return from + (to - from) * v;
+}
+var eases = { linear: (t) => t, easeIn: (t) => t * t * t, easeOut: (t) => 1 - (1 - t) ** 3, easeInOut: (t) => t < 0.5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2 };
+function interpolate(x, input, output, options = {}) {
+  if (input.length !== output.length || input.length < 2) throw new Error("interpolate needs two lists of the same length, at least two long");
+  let i = 1;
+  while (i < input.length - 1 && x > input[i]) i++;
+  let t = (x - input[i - 1]) / (input[i] - input[i - 1] || 1);
+  if (options.clamp !== false) t = Math.min(1, Math.max(0, t));
+  const ease = typeof options.easing === "function" ? options.easing : eases[options.easing ?? "linear"];
+  if (!ease) throw new Error(`Unknown easing "${String(options.easing)}"`);
+  return output[i - 1] + (output[i] - output[i - 1]) * (t >= 0 && t <= 1 ? ease(t) : t);
+}
+function createVideo(options) {
+  const fps = options.fps ?? 30, scenes = [], variables = {}, components = {}, assets = [];
+  let exportSettings;
+  const idMaker = (taken2 = /* @__PURE__ */ new Set()) => {
+    const counts = {};
+    const idFor = (type, wanted) => {
+      if (wanted !== void 0) {
+        if (taken2.has(wanted)) throw new Error(`The id "${wanted}" is used twice; ids must be unique`);
+        taken2.add(wanted);
+        return wanted;
+      }
+      let id;
+      do {
+        id = `${type}-${counts[type] = (counts[type] ?? 0) + 1}`;
+      } while (taken2.has(id));
+      taken2.add(id);
+      return id;
+    };
+    const withIds2 = (input) => {
+      const copy = { ...input };
+      const type = String(copy.type ?? (copy.use ? "use" : "layer"));
+      copy.id = idFor(type, copy.id);
+      if (Array.isArray(copy.children)) copy.children = copy.children.map(withIds2);
+      return copy;
+    };
+    return { taken: taken2, withIds: withIds2 };
+  };
+  const { taken, withIds } = idMaker();
+  const builder = {
+    fps,
+    width: options.width,
+    height: options.height,
+    frames: (seconds) => Math.round(seconds * fps),
+    scene(id, sceneOptions, build) {
+      const { seconds, duration, ...rest } = sceneOptions, durationFrames = duration ?? (seconds !== void 0 ? Math.round(seconds * fps) : void 0);
+      if (!durationFrames || durationFrames < 1) throw new Error(`Scene "${id}" needs a duration in frames or seconds`);
+      taken.add(id);
+      const layers = [], api = { layers, add: (...added) => {
+        for (const item of added.flat()) layers.push(withIds(item));
+        return api;
+      } };
+      if (Array.isArray(build)) api.add(...build);
+      else build(api);
+      scenes.push({ id, name: rest.name ?? id, ...rest, durationFrames, layers });
+      return builder;
+    },
+    variable(name, declaration) {
+      variables[name] = declaration;
+      return builder;
+    },
+    component(name, definition) {
+      const own = idMaker();
+      components[name] = { params: {}, ...definition, layers: definition.layers.map(own.withIds) };
+      return builder;
+    },
+    asset(id, asset) {
+      assets.push({ id, ...asset });
+      return builder;
+    },
+    export(settings) {
+      exportSettings = { ...exportSettings ?? {}, ...settings };
+      return builder;
+    },
+    toJSON() {
+      if (!scenes.length) throw new Error("A video needs at least one scene");
+      const motionBlur = options.motionBlur === true ? { samples: 4, shutter: 180 } : options.motionBlur || void 0;
+      return {
+        $schema: "./composition.schema.json",
+        version: "1.0",
+        id: options.id,
+        name: options.name ?? options.id,
+        width: options.width,
+        height: options.height,
+        fps,
+        durationFrames: options.durationSeconds !== void 0 ? Math.round(options.durationSeconds * fps) : "auto",
+        ...options.background !== void 0 ? { background: options.background } : {},
+        ...motionBlur ? { motionBlur } : {},
+        ...options.tempo ? { tempo: options.tempo } : {},
+        ...Object.keys(variables).length ? { variables } : {},
+        ...Object.keys(components).length ? { components } : {},
+        ...assets.length ? { assets } : {},
+        ...exportSettings ? { export: exportSettings } : {},
+        scenes: structuredClone(scenes)
+      };
+    }
+  };
+  return builder;
+}
+async function resolveBuildable(value) {
+  const resolved = typeof value === "function" ? await value() : value;
+  if (resolved && typeof resolved.toJSON === "function") return resolved.toJSON();
+  if (resolved && typeof resolved === "object") return resolved;
+  throw new Error("The file must export a video from createVideo(...), a composition object, or a function returning one");
+}
+export {
+  audio,
+  captions,
+  circle,
+  clip,
+  code,
+  createVideo,
+  fadeIn,
+  fadeOut,
+  group,
+  html,
+  image,
+  interpolate,
+  keyframes,
+  lottie,
+  path,
+  rect,
+  resolveBuildable,
+  riseIn,
+  sample,
+  sfx,
+  shader,
+  spring,
+  text,
+  tween,
+  use
+};