@rslsp1/fa-app-tools 10.0.1 → 10.3.2

package/dist/chunk-ACB2543O.js

@@ -0,0 +1,218 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/lib/szenen/cameraContract.ts
+var CAMERA_ASPECT_RATIOS = ["1:1", "4:3", "3:4", "16:9", "9:16"];
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+function cameraAspectRatioValue(aspectRatio) {
+  if (!/^[1-9][0-9]*(\.[0-9]+)?:[1-9][0-9]*(\.[0-9]+)?$/.test(aspectRatio)) {
+    throw new Error(`Ung\xFCltiges Kamera-Seitenverh\xE4ltnis \u201E${aspectRatio}\u201C.`);
+  }
+  const [width, height] = aspectRatio.split(":").map(Number);
+  const ratio = width / height;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || !Number.isFinite(ratio) || ratio <= 0) {
+    throw new Error(`Kamera-Seitenverh\xE4ltnis \u201E${aspectRatio}\u201C ist nicht darstellbar.`);
+  }
+  return ratio;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  const record = object(value);
+  if (record) return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
+  return _nullishCoalesce(JSON.stringify(value), () => ( "undefined"));
+}
+function camerasOf(payload) {
+  const cameras = _optionalChain([object, 'call', _ => _(_optionalChain([object, 'call', _2 => _2(payload), 'optionalAccess', _3 => _3.camera_rig])), 'optionalAccess', _4 => _4.cameras]);
+  return Array.isArray(cameras) ? cameras : [];
+}
+function checkCameraAspectRatioChanges(type, payload, previousPayloads = []) {
+  if (type !== "scene_setup") return [];
+  const previous = previousPayloads.flatMap(camerasOf);
+  return camerasOf(payload).flatMap((value, index) => {
+    const camera = object(value);
+    if (!camera) return [];
+    if (typeof camera.aspect_ratio === "string") {
+      try {
+        cameraAspectRatioValue(camera.aspect_ratio);
+        return [];
+      } catch (error) {
+        return [{ instancePath: `/camera_rig/cameras/${index}/aspect_ratio`, keyword: "aspect_ratio", message: error.message }];
+      }
+    }
+    if (camera.aspect_ratio === void 0 && previous.some((old) => canonical(old) === canonical(camera))) return [];
+    return [{
+      instancePath: `/camera_rig/cameras/${index}/aspect_ratio`,
+      keyword: "required",
+      message: `Kamera \u201E${String(_nullishCoalesce(camera.camera_id, () => ( index)))}\u201C wurde neu angelegt oder ge\xE4ndert. Bitte ihr Seitenverh\xE4ltnis ausdr\xFCcklich speichern.`
+    }];
+  });
+}
+function cameraPerspective(camera) {
+  if (!camera.aspect_ratio) throw new Error(`Kamera \u201E${camera.camera_id}\u201C hat kein gespeichertes Seitenverh\xE4ltnis.`);
+  const lens = object(_optionalChain([object, 'call', _5 => _5(camera.preset), 'optionalAccess', _6 => _6.lens]));
+  const focal = _optionalChain([lens, 'optionalAccess', _7 => _7.focal_length_mm]);
+  const sensor = _optionalChain([lens, 'optionalAccess', _8 => _8.sensor_width_mm]);
+  if (typeof focal !== "number" || !Number.isFinite(focal) || focal <= 0 || typeof sensor !== "number" || !Number.isFinite(sensor) || sensor <= 0) {
+    throw new Error(`Kamera \u201E${camera.camera_id}\u201C hat kein aufgel\xF6stes Objektiv mit Brennweite und Sensorbreite.`);
+  }
+  if (_optionalChain([object, 'call', _9 => _9(camera.preset), 'optionalAccess', _10 => _10.projection]) !== "perspective") {
+    throw new Error(`Kamera \u201E${camera.camera_id}\u201C verwendet keine perspektivische Projektion.`);
+  }
+  const aspect = cameraAspectRatioValue(camera.aspect_ratio);
+  return {
+    aspect_ratio: camera.aspect_ratio,
+    aspect,
+    focal_length_mm: focal,
+    sensor_width_mm: sensor,
+    vertical_fov_deg: 2 * Math.atan(sensor / (2 * focal * aspect)) * 180 / Math.PI
+  };
+}
+function frozenCameraAspectRatio(input) {
+  const aspect = _optionalChain([object, 'call', _11 => _11(_optionalChain([object, 'call', _12 => _12(input), 'optionalAccess', _13 => _13.camera])), 'optionalAccess', _14 => _14.aspect_ratio]);
+  if (aspect === void 0) return void 0;
+  if (typeof aspect !== "string") throw new Error("Das eingefrorene Kamera-Seitenverh\xE4ltnis ist kein Text.");
+  cameraAspectRatioValue(aspect);
+  return aspect;
+}
+
+// src/lib/szenen/stage3d.ts
+var STAGE_CATALOGUE = [
+  { label: "Mensch", type: "subject", dimensions: [0.55, 0.35, 1.75] },
+  { label: "Stuhl", type: "object", dimensions: [0.5, 0.5, 0.9] },
+  { label: "Tisch", type: "surface", dimensions: [1.2, 0.7, 0.75] },
+  { label: "Lampe", type: "light", dimensions: [0.35, 0.35, 1.5] }
+];
+var stageColor = (type) => _nullishCoalesce(({ subject: "#df995f", light: "#ffe084", surface: "#65aabc", object: "#b998d9" })[type], () => ( "#9bafbc"));
+function stageColors(nodes) {
+  const result = /* @__PURE__ */ Object.create(null);
+  const used = /* @__PURE__ */ new Set();
+  const names = { subject: "orange", light: "yellow", surface: "cyan", object: "purple" };
+  let next = 0;
+  for (const node of [...nodes].sort((a, b) => a.node_id.localeCompare(b.node_id))) {
+    let hex = stageColor(node.type), name = _nullishCoalesce(names[node.type], () => ( "blue grey"));
+    while (used.has(hex)) {
+      const hue = (next++ * 137.508 + 25) % 360;
+      const channel = (n) => {
+        const k = (n + hue / 30) % 12;
+        return Math.round(255 * (0.62 - 0.29 * Math.max(-1, Math.min(k - 3, 9 - k, 1)))).toString(16).padStart(2, "0");
+      };
+      hex = `#${channel(0)}${channel(8)}${channel(4)}`;
+      name = `${["red", "orange", "yellow", "green", "cyan", "blue", "purple", "pink"][Math.round(hue / 45) % 8]} (${hex})`;
+    }
+    used.add(hex);
+    result[node.node_id] = { hex, name };
+  }
+  return result;
+}
+var stageTypeLabel = (type) => _nullishCoalesce(({ subject: "Person", light: "Licht", surface: "Fl\xE4che", object: "Objekt" })[type], () => ( type));
+function vector3(value, label) {
+  if (!Array.isArray(value) || value.length !== 3 || value.some((n) => typeof n !== "number" || !Number.isFinite(n))) {
+    throw new Error(`${label}: drei endliche Koordinaten erforderlich.`);
+  }
+  return [...value];
+}
+function dragPosition(position, point, plane) {
+  const p = vector3(position, "Position");
+  const q = vector3(point, "Drag");
+  return plane === "top" ? [q[0], q[1], p[2]] : plane === "side" ? [q[0], p[1], q[2]] : p;
+}
+function stageNode(node) {
+  if (!node.placement) throw new Error(`\u201E${node.node_id}\u201C hat keine Weltplatzierung.`);
+  if (!node.proxy_3d) throw new Error(`\u201E${node.node_id}\u201C hat keine Proxy-Geometrie. Bitte Ma\xDFe festlegen.`);
+  const dimensions = vector3(node.proxy_3d.dimensions, `Ma\xDFe von ${node.node_id}`);
+  if (dimensions.some((d) => d <= 0)) throw new Error(`\u201E${node.node_id}\u201C braucht positive Proxy-Ma\xDFe.`);
+  return {
+    node_id: node.node_id,
+    type: node.type,
+    primitive: node.proxy_3d.primitive,
+    dimensions,
+    position: vector3(node.placement.position, `Position von ${node.node_id}`),
+    rotation: vector3(_nullishCoalesce(node.placement.rotation_euler_deg, () => ( [0, 0, 0])), "Rotation"),
+    scale: vector3(_nullishCoalesce(node.placement.scale, () => ( [1, 1, 1])), "Skalierung"),
+    anchors: node.anchors
+  };
+}
+function stageFrame(input) {
+  if (input.capabilities.can_place !== "yes") throw new Error("Die Szene ben\xF6tigt Meterma\xDFe und ein Scene Setup in Z-up-Koordinaten.");
+  const visible = input.scene.nodes.filter((n) => !n.hidden);
+  const colors = stageColors(visible);
+  const nodes = visible.map((n) => ({ ...stageNode(n), preview_color: colors[n.node_id] }));
+  if (!input.camera) throw new Error("Bitte eine Kamera ausw\xE4hlen.");
+  const optical = cameraPerspective(input.camera);
+  const placement = input.camera.placement;
+  if (_optionalChain([placement, 'optionalAccess', _15 => _15.mode]) !== "absolute") throw new Error("Diese Kamera verwendet eine Pattern-Platzierung. F\xFCr den MVP bitte eine explizite Weltposition speichern.");
+  const position = vector3(placement.position, "Kameraposition");
+  const orientation = input.camera.orientation;
+  if (_optionalChain([orientation, 'optionalAccess', _16 => _16.mode]) !== "explicit" && _optionalChain([orientation, 'optionalAccess', _17 => _17.mode]) !== "look_at") throw new Error("Bitte eine explizite Kameraausrichtung oder ein Blickziel festlegen.");
+  if (orientation.mode === "explicit") vector3(orientation.rotation_euler_deg, "Kameraausrichtung");
+  return { nodes, camera: { ...input.camera, ...optical, position, orientation } };
+}
+function planeAxes(plane) {
+  return plane === "top" ? [0, 1] : [0, 2];
+}
+function snapPosition(position, plane, step) {
+  const p = vector3(position, "Position");
+  for (const axis of planeAxes(plane)) p[axis] = Math.round(p[axis] / step) * step;
+  return p.map((v) => Number(v.toFixed(6)));
+}
+function nudgePosition(position, plane, right, up) {
+  const p = vector3(position, "Position");
+  const [u, v] = planeAxes(plane);
+  p[u] = Number((p[u] + right).toFixed(6));
+  p[v] = Number((p[v] + up).toFixed(6));
+  return p;
+}
+function fitPlaneView(points, plane, width, height) {
+  if (!points.length || width <= 0 || height <= 0) return { center: [0, 0], zoom: 60 };
+  const [u, v] = planeAxes(plane);
+  const us = points.map((p) => p[u]), vs = points.map((p) => p[v]);
+  const [minU, maxU, minV, maxV] = [Math.min(...us), Math.max(...us), Math.min(...vs), Math.max(...vs)];
+  const spanU = Math.max(maxU - minU, 2), spanV = Math.max(maxV - minV, 2);
+  const zoom = Math.min(width / (spanU * 1.25), height / (spanV * 1.25));
+  return { center: [(minU + maxU) / 2, (minV + maxV) / 2], zoom: clampZoom(zoom) };
+}
+var clampZoom = (zoom) => Math.min(800, Math.max(8, zoom));
+function screenToPlane(view, dx, dy) {
+  return [view.center[0] + dx / view.zoom, view.center[1] - dy / view.zoom];
+}
+function zoomPlaneView(view, factor, dx, dy) {
+  const zoom = clampZoom(view.zoom * factor);
+  const [u, v] = screenToPlane(view, dx, dy);
+  return { zoom, center: [u - dx / zoom, v + dy / zoom] };
+}
+function gridStep(zoom, minPx = 14) {
+  return _nullishCoalesce([0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 25, 50].find((step) => step * zoom >= minPx), () => ( 100));
+}
+function withStagePositions(input, nodes, camera) {
+  if (!nodes.size && !camera) return input;
+  const next = {
+    ...input,
+    scene: { ...input.scene, nodes: input.scene.nodes.map((n) => nodes.has(n.node_id) && n.placement ? { ...n, placement: { ...n.placement, position: nodes.get(n.node_id) } } : n) }
+  };
+  if (camera && input.camera) next.camera = { ...input.camera, placement: { ...input.camera.placement, position: camera } };
+  return next;
+}
+var roundMeters = (value) => Math.round(value * 1e3) / 1e3;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CAMERA_ASPECT_RATIOS = CAMERA_ASPECT_RATIOS; exports.cameraAspectRatioValue = cameraAspectRatioValue; exports.checkCameraAspectRatioChanges = checkCameraAspectRatioChanges; exports.cameraPerspective = cameraPerspective; exports.frozenCameraAspectRatio = frozenCameraAspectRatio; exports.STAGE_CATALOGUE = STAGE_CATALOGUE; exports.stageColor = stageColor; exports.stageColors = stageColors; exports.stageTypeLabel = stageTypeLabel; exports.vector3 = vector3; exports.dragPosition = dragPosition; exports.stageNode = stageNode; exports.stageFrame = stageFrame; exports.planeAxes = planeAxes; exports.snapPosition = snapPosition; exports.nudgePosition = nudgePosition; exports.fitPlaneView = fitPlaneView; exports.clampZoom = clampZoom; exports.screenToPlane = screenToPlane; exports.zoomPlaneView = zoomPlaneView; exports.gridStep = gridStep; exports.withStagePositions = withStagePositions; exports.roundMeters = roundMeters;

package/dist/chunk-FTLEDU6C.js

@@ -0,0 +1,157 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/lib/szenen/versionDag.ts
+var VersionDagError = class extends Error {
+};
+function buildVersionDag(versions) {
+  if (versions.length === 0) {
+    throw new VersionDagError("Versions-DAG ohne Versionen ist nicht aufbaubar.");
+  }
+  const elementId = versions[0].element_id;
+  const nodes = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const version of versions) {
+    if (!version.version_id) {
+      throw new VersionDagError("Version ohne version_id.");
+    }
+    if (version.element_id !== elementId) {
+      throw new VersionDagError(
+        `Version ${version.version_id} gehoert zu Element ${version.element_id}, erwartet ${elementId}. Ein DAG umfasst genau ein Element.`
+      );
+    }
+    if (nodes.has(version.version_id)) {
+      throw new VersionDagError(`Version ${version.version_id} kommt doppelt vor.`);
+    }
+    nodes.set(version.version_id, version);
+    if (!children.has(version.version_id)) children.set(version.version_id, []);
+  }
+  for (const version of versions) {
+    const seenParents = /* @__PURE__ */ new Set();
+    for (const link of version.parents) {
+      if (link.parent_version_id === version.version_id) {
+        throw new VersionDagError(`Version ${version.version_id} ist ihr eigener Parent.`);
+      }
+      if (!nodes.has(link.parent_version_id)) {
+        throw new VersionDagError(
+          `Version ${version.version_id} verweist auf unbekannten Parent ${link.parent_version_id}. Der Graph waere unvollstaendig.`
+        );
+      }
+      if (seenParents.has(link.parent_version_id)) {
+        throw new VersionDagError(
+          `Version ${version.version_id} nennt Parent ${link.parent_version_id} doppelt.`
+        );
+      }
+      seenParents.add(link.parent_version_id);
+      children.get(link.parent_version_id).push(version.version_id);
+    }
+  }
+  assertAcyclic(nodes);
+  const versionIds = versions.map((v) => v.version_id);
+  const closure = (start, step) => {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [...step(start)];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (seen.has(current)) continue;
+      seen.add(current);
+      stack.push(...step(current));
+    }
+    return seen;
+  };
+  const parentIdsOf = (id) => (_nullishCoalesce(_optionalChain([nodes, 'access', _ => _.get, 'call', _2 => _2(id), 'optionalAccess', _3 => _3.parents]), () => ( []))).map((p) => p.parent_version_id);
+  const childIdsOf = (id) => _nullishCoalesce(children.get(id), () => ( []));
+  return {
+    elementId,
+    versionIds,
+    get: (versionId) => nodes.get(versionId),
+    parentsOf: (versionId) => _nullishCoalesce(_optionalChain([nodes, 'access', _4 => _4.get, 'call', _5 => _5(versionId), 'optionalAccess', _6 => _6.parents]), () => ( [])),
+    childrenOf: (versionId) => childIdsOf(versionId),
+    heads: () => versionIds.filter((id) => childIdsOf(id).length === 0),
+    roots: () => versionIds.filter((id) => parentIdsOf(id).length === 0),
+    hasFork() {
+      return this.heads().length > 1;
+    },
+    ancestorsOf: (versionId) => closure(versionId, parentIdsOf),
+    descendantsOf: (versionId) => closure(versionId, childIdsOf),
+    isAncestorOf(candidate, versionId) {
+      return this.ancestorsOf(versionId).has(candidate);
+    }
+  };
+}
+function assertAcyclic(nodes) {
+  const OPEN = 1;
+  const DONE = 2;
+  const state = /* @__PURE__ */ new Map();
+  for (const start of nodes.keys()) {
+    if (state.get(start) === DONE) continue;
+    const stack = [
+      { id: start, next: 0, path: [start] }
+    ];
+    state.set(start, OPEN);
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const parents = nodes.get(frame.id).parents;
+      if (frame.next >= parents.length) {
+        state.set(frame.id, DONE);
+        stack.pop();
+        continue;
+      }
+      const parentId = parents[frame.next++].parent_version_id;
+      const parentState = state.get(parentId);
+      if (parentState === OPEN) {
+        throw new VersionDagError(
+          `Zyklus im Versions-DAG: ${[...frame.path, parentId].join(" -> ")}`
+        );
+      }
+      if (parentState !== DONE) {
+        state.set(parentId, OPEN);
+        stack.push({ id: parentId, next: 0, path: [...frame.path, parentId] });
+      }
+    }
+  }
+}
+function resolvePreferredHead(options) {
+  const { dag, workingContextId, inheritanceChain = [], owningContextId, selections = [] } = options;
+  const heads = dag.heads();
+  const ignoredSelections = [];
+  const byContext = /* @__PURE__ */ new Map();
+  for (const selection of selections) {
+    if (!dag.get(selection.version_id)) {
+      ignoredSelections.push(selection);
+      continue;
+    }
+    if (!byContext.has(selection.context_id)) byContext.set(selection.context_id, selection);
+  }
+  const candidates = [
+    { contextId: workingContextId, source: "context" },
+    ...inheritanceChain.map((contextId) => ({ contextId, source: "inherited" })),
+    ...owningContextId ? [{ contextId: owningContextId, source: "owning" }] : []
+  ];
+  for (const candidate of candidates) {
+    const selection = byContext.get(candidate.contextId);
+    if (!selection) continue;
+    return {
+      resolution: {
+        kind: "selected",
+        versionId: selection.version_id,
+        source: candidate.source,
+        contextId: candidate.contextId,
+        heads,
+        stale: !heads.includes(selection.version_id)
+      },
+      ignoredSelections
+    };
+  }
+  if (heads.length === 1) {
+    return { resolution: { kind: "single", versionId: heads[0], heads }, ignoredSelections };
+  }
+  return { resolution: { kind: "fork", heads }, ignoredSelections };
+}
+function preferredVersionId(resolution) {
+  return resolution.kind === "fork" ? null : resolution.versionId;
+}
+
+
+
+
+
+
+exports.VersionDagError = VersionDagError; exports.buildVersionDag = buildVersionDag; exports.resolvePreferredHead = resolvePreferredHead; exports.preferredVersionId = preferredVersionId;