@playdrop/playdrop-cli 0.7.15 → 0.7.16

package/node_modules/@playdrop/boxel-three/dist/src/instantiate.js

@@ -1,70 +1,96 @@
-import { createBoxelScene } from './scene.js';
-import { createBoxelSceneGraph } from './exporters/glb.js';
-import { buildEntitySkinnedMesh } from './skinned-mesh.js';
-import { buildAnimations } from './animations.js';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var instantiate_exports = {};
+__export(instantiate_exports, {
+  instantiateEntityObject3D: () => instantiateEntityObject3D
+});
+module.exports = __toCommonJS(instantiate_exports);
+var import_scene = require("./scene.js");
+var import_glb = require("./exporters/glb.js");
+var import_skinned_mesh = require("./skinned-mesh.js");
+var import_animations = require("./animations.js");
 function instantiateHierarchy(options) {
-    const { THREE, entity } = options;
-    const scene = createBoxelScene({ THREE, entity });
-    const clips = scene.animations.map(animation => animation.clip);
-    return {
-        mode: 'hierarchy',
-        object: scene.root,
-        scene,
-        clips,
-        findNode: (nodeId) => scene.nodes.get(nodeId)?.object,
-        forEachNode: (visitor) => {
-            scene.nodes.forEach(meta => visitor(meta.object, meta.id));
-        },
-        dispose: () => {
-            scene.dispose();
-        },
-    };
+  const { THREE, entity } = options;
+  const scene = (0, import_scene.createBoxelScene)({ THREE, entity });
+  const clips = scene.animations.map((animation) => animation.clip);
+  return {
+    mode: "hierarchy",
+    object: scene.root,
+    scene,
+    clips,
+    findNode: (nodeId) => scene.nodes.get(nodeId)?.object,
+    forEachNode: (visitor) => {
+      scene.nodes.forEach((meta) => visitor(meta.object, meta.id));
+    },
+    dispose: () => {
+      scene.dispose();
+    }
+  };
 }
 function instantiateMerged(options) {
-    const { THREE, entity } = options;
-    const graph = createBoxelSceneGraph({ THREE, model: entity, mode: 'merged' });
-    const { root } = graph;
-    return {
-        mode: 'merged',
-        object: root,
-        dispose: () => {
-            graph.dispose();
-        },
-    };
+  const { THREE, entity } = options;
+  const graph = (0, import_glb.createBoxelSceneGraph)({ THREE, model: entity, mode: "merged" });
+  const { root } = graph;
+  return {
+    mode: "merged",
+    object: root,
+    dispose: () => {
+      graph.dispose();
+    }
+  };
 }
 function instantiateSkinned(options) {
-    const { THREE, entity } = options;
-    const result = buildEntitySkinnedMesh({ THREE, entity });
-    const boneMap = result.boneMap;
-    const animations = buildAnimations(THREE, entity, boneMap);
-    const clips = animations.map(animation => animation.clip);
-    return {
-        mode: 'skinned',
-        object: result.mesh,
-        skeleton: result.skeleton,
-        boneMap,
-        clips,
-        stats: result.stats,
-        warnings: result.warnings,
-        findBone: (nodeId) => boneMap.get(nodeId),
-        forEachBone: (visitor) => {
-            boneMap.forEach((bone, nodeId) => visitor(bone, nodeId));
-        },
-        dispose: () => {
-            result.dispose();
-        },
-    };
-}
-export function instantiateEntityObject3D(options) {
-    const mode = options.mode ?? 'hierarchy';
-    switch (mode) {
-        case 'hierarchy':
-            return instantiateHierarchy(options);
-        case 'merged':
-            return instantiateMerged(options);
-        case 'skinned':
-            return instantiateSkinned(options);
-        default:
-            throw new Error(`Unknown entity instantiation mode: ${String(mode)}`);
+  const { THREE, entity } = options;
+  const result = (0, import_skinned_mesh.buildEntitySkinnedMesh)({ THREE, entity });
+  const boneMap = result.boneMap;
+  const animations = (0, import_animations.buildAnimations)(THREE, entity, boneMap);
+  const clips = animations.map((animation) => animation.clip);
+  return {
+    mode: "skinned",
+    object: result.mesh,
+    skeleton: result.skeleton,
+    boneMap,
+    clips,
+    stats: result.stats,
+    warnings: result.warnings,
+    findBone: (nodeId) => boneMap.get(nodeId),
+    forEachBone: (visitor) => {
+      boneMap.forEach((bone, nodeId) => visitor(bone, nodeId));
+    },
+    dispose: () => {
+      result.dispose();
     }
+  };
+}
+function instantiateEntityObject3D(options) {
+  const mode = options.mode ?? "hierarchy";
+  switch (mode) {
+    case "hierarchy":
+      return instantiateHierarchy(options);
+    case "merged":
+      return instantiateMerged(options);
+    case "skinned":
+      return instantiateSkinned(options);
+    default:
+      throw new Error(`Unknown entity instantiation mode: ${String(mode)}`);
+  }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  instantiateEntityObject3D
+});

package/node_modules/@playdrop/boxel-three/dist/src/nodes.js

@@ -1,63 +1,88 @@
-import { createPrimitiveObject, createBoundingBoxMesh } from './builders.js';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nodes_exports = {};
+__export(nodes_exports, {
+  buildNodeObject: () => buildNodeObject
+});
+module.exports = __toCommonJS(nodes_exports);
+var import_builders = require("./builders.js");
 function applyNodeTransforms(context, object, node) {
-    object.position.set(node.position[0], node.position[1], node.position[2]);
-    if (node.rotation) {
-        object.rotation.set(context.THREE.MathUtils.degToRad(node.rotation[0]), context.THREE.MathUtils.degToRad(node.rotation[1]), context.THREE.MathUtils.degToRad(node.rotation[2]));
-    }
-    if (node.scale) {
-        object.scale.set(node.scale[0], node.scale[1], node.scale[2]);
-    }
+  object.position.set(node.position[0], node.position[1], node.position[2]);
+  if (node.rotation) {
+    object.rotation.set(context.THREE.MathUtils.degToRad(node.rotation[0]), context.THREE.MathUtils.degToRad(node.rotation[1]), context.THREE.MathUtils.degToRad(node.rotation[2]));
+  }
+  if (node.scale) {
+    object.scale.set(node.scale[0], node.scale[1], node.scale[2]);
+  }
 }
-export function buildNodeObject(context, node, visitedPrimitives = new Set()) {
-    const connectMode = node.connect ?? 'none';
-    const object = new context.THREE.Object3D();
-    object.name = node.id;
-    object.userData = {
-        ...(object.userData ?? {}),
-        kind: 'entity-node',
-        nodeId: node.id,
-        primitiveId: node.mesh ?? (object.userData?.primitiveId ?? undefined),
-        connectMode,
-    };
-    if (node.size) {
-        object.userData.size = [...node.size];
-    }
-    if (node.center) {
-        object.userData.center = [...node.center];
-    }
-    applyNodeTransforms(context, object, node);
-    const nodes = new Map();
-    nodes.set(node.id, object);
-    if (node.mesh) {
-        const primitive = context.primitivesById.get(node.mesh);
-        if (primitive) {
-            const mesh = createPrimitiveObject(context, primitive, 'centered', visitedPrimitives);
-            if (mesh) {
-                if (node.center) {
-                    mesh.position.set(node.center[0], node.center[1], node.center[2]);
-                }
-                object.add(mesh);
-                if (mesh.userData?.size && !object.userData.size) {
-                    object.userData.size = mesh.userData.size;
-                }
-                if (mesh.userData?.sockets) {
-                    object.userData.sockets = mesh.userData.sockets;
-                }
-            }
-        }
-    }
-    else if (node.size) {
-        const mesh = createBoundingBoxMesh(context, node.size);
-        mesh.name = `${node.id}__placeholder`;
+function buildNodeObject(context, node, visitedPrimitives = /* @__PURE__ */ new Set()) {
+  const connectMode = node.connect ?? "none";
+  const object = new context.THREE.Object3D();
+  object.name = node.id;
+  object.userData = {
+    ...object.userData ?? {},
+    kind: "entity-node",
+    nodeId: node.id,
+    primitiveId: node.mesh ?? (object.userData?.primitiveId ?? void 0),
+    connectMode
+  };
+  if (node.size) {
+    object.userData.size = [...node.size];
+  }
+  if (node.center) {
+    object.userData.center = [...node.center];
+  }
+  applyNodeTransforms(context, object, node);
+  const nodes = /* @__PURE__ */ new Map();
+  nodes.set(node.id, object);
+  if (node.mesh) {
+    const primitive = context.primitivesById.get(node.mesh);
+    if (primitive) {
+      const mesh = (0, import_builders.createPrimitiveObject)(context, primitive, "centered", visitedPrimitives);
+      if (mesh) {
         if (node.center) {
-            mesh.position.set(node.center[0], node.center[1], node.center[2]);
+          mesh.position.set(node.center[0], node.center[1], node.center[2]);
         }
         object.add(mesh);
+        if (mesh.userData?.size && !object.userData.size) {
+          object.userData.size = mesh.userData.size;
+        }
+        if (mesh.userData?.sockets) {
+          object.userData.sockets = mesh.userData.sockets;
+        }
+      }
+    }
+  } else if (node.size) {
+    const mesh = (0, import_builders.createBoundingBoxMesh)(context, node.size);
+    mesh.name = `${node.id}__placeholder`;
+    if (node.center) {
+      mesh.position.set(node.center[0], node.center[1], node.center[2]);
     }
-    node.children.forEach(child => {
-        const childResult = buildNodeObject(context, child, new Set(visitedPrimitives));
-        object.add(childResult.object);
-        childResult.nodes.forEach((value, key) => nodes.set(key, value));
-    });
-    return { object, nodes };
+    object.add(mesh);
+  }
+  node.children.forEach((child) => {
+    const childResult = buildNodeObject(context, child, new Set(visitedPrimitives));
+    object.add(childResult.object);
+    childResult.nodes.forEach((value, key) => nodes.set(key, value));
+  });
+  return { object, nodes };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildNodeObject
+});

package/node_modules/@playdrop/boxel-three/dist/src/overlays.js

@@ -1,97 +1,123 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var overlays_exports = {};
+__export(overlays_exports, {
+  attachBoxelOverlays: () => attachBoxelOverlays
+});
+module.exports = __toCommonJS(overlays_exports);
 function createOriginHelper(THREE, options) {
-    const axes = new THREE.AxesHelper(0.5);
-    if (options.opacity !== undefined) {
-        const axesMaterial = axes.material;
-        axesMaterial.opacity = options.opacity;
-        axesMaterial.transparent = options.opacity < 1;
-    }
-    return axes;
+  const axes = new THREE.AxesHelper(0.5);
+  if (options.opacity !== void 0) {
+    const axesMaterial = axes.material;
+    axesMaterial.opacity = options.opacity;
+    axesMaterial.transparent = options.opacity < 1;
+  }
+  return axes;
 }
 function createBoundsHelper(THREE, size, options) {
-    const geometry = new THREE.BoxGeometry(size[0], size[1], size[2]);
-    const material = new THREE.LineDashedMaterial({
-        color: options.color ?? 0xffffff,
-        dashSize: options.dashed ? 0.1 : 1,
-        gapSize: options.dashed ? 0.05 : 0,
-        transparent: options.opacity !== undefined,
-        opacity: options.opacity ?? 1,
-    });
-    const edges = new THREE.EdgesGeometry(geometry);
-    const line = new THREE.LineSegments(edges, material);
-    line.computeLineDistances();
-    return line;
+  const geometry = new THREE.BoxGeometry(size[0], size[1], size[2]);
+  const material = new THREE.LineDashedMaterial({
+    color: options.color ?? 16777215,
+    dashSize: options.dashed ? 0.1 : 1,
+    gapSize: options.dashed ? 0.05 : 0,
+    transparent: options.opacity !== void 0,
+    opacity: options.opacity ?? 1
+  });
+  const edges = new THREE.EdgesGeometry(geometry);
+  const line = new THREE.LineSegments(edges, material);
+  line.computeLineDistances();
+  return line;
 }
 function createSocketHelper(THREE, options) {
-    const geometry = new THREE.SphereGeometry(0.05, 8, 8);
-    const material = new THREE.MeshBasicMaterial({
-        color: options.color ?? 0xffff00,
-        transparent: options.opacity !== undefined,
-        opacity: options.opacity ?? 1,
-        wireframe: true,
-    });
-    return new THREE.Mesh(geometry, material);
+  const geometry = new THREE.SphereGeometry(0.05, 8, 8);
+  const material = new THREE.MeshBasicMaterial({
+    color: options.color ?? 16776960,
+    transparent: options.opacity !== void 0,
+    opacity: options.opacity ?? 1,
+    wireframe: true
+  });
+  return new THREE.Mesh(geometry, material);
 }
 function disposeObjectResources(object) {
-    object.traverse(entry => {
-        const mesh = entry;
-        if ('geometry' in mesh && mesh.geometry) {
-            const geometry = mesh.geometry;
-            geometry?.dispose?.();
-        }
-        if ('material' in mesh && mesh.material) {
-            const material = mesh.material;
-            const disposeMaterial = (mat) => {
-                const typedMaterial = mat;
-                typedMaterial.map?.dispose?.();
-                typedMaterial.emissiveMap?.dispose?.();
-                typedMaterial.dispose?.();
-            };
-            if (Array.isArray(material))
-                material.forEach(disposeMaterial);
-            else
-                disposeMaterial(material);
-        }
-    });
-}
-export function attachBoxelOverlays(context, options = {}) {
-    const { THREE, target } = context;
-    const overlays = {
-        dispose: () => {
-            if (overlays.origin) {
-                target.remove(overlays.origin);
-                disposeObjectResources(overlays.origin);
-            }
-            overlays.bounds?.forEach(bound => {
-                target.remove(bound);
-                disposeObjectResources(bound);
-            });
-            overlays.sockets?.forEach(socket => {
-                target.remove(socket);
-                disposeObjectResources(socket);
-            });
-            overlays.origin = undefined;
-            overlays.bounds = undefined;
-            overlays.sockets = undefined;
-        },
-    };
-    if (options.origin) {
-        const origin = createOriginHelper(THREE, options);
-        overlays.origin = origin;
-        target.add(origin);
+  object.traverse((entry) => {
+    const mesh = entry;
+    if ("geometry" in mesh && mesh.geometry) {
+      const geometry = mesh.geometry;
+      geometry?.dispose?.();
     }
-    if (options.bounds && target.userData?.size) {
-        const bound = createBoundsHelper(THREE, target.userData.size, options);
-        overlays.bounds = [bound];
-        target.add(bound);
+    if ("material" in mesh && mesh.material) {
+      const material = mesh.material;
+      const disposeMaterial = (mat) => {
+        const typedMaterial = mat;
+        typedMaterial.map?.dispose?.();
+        typedMaterial.emissiveMap?.dispose?.();
+        typedMaterial.dispose?.();
+      };
+      if (Array.isArray(material))
+        material.forEach(disposeMaterial);
+      else
+        disposeMaterial(material);
     }
-    if (options.sockets && target.userData?.sockets) {
-        const sockets = target.userData.sockets.map(position => {
-            const helper = createSocketHelper(THREE, options);
-            helper.position.set(position[0], position[1], position[2]);
-            target.add(helper);
-            return helper;
-        });
-        overlays.sockets = sockets;
+  });
+}
+function attachBoxelOverlays(context, options = {}) {
+  const { THREE, target } = context;
+  const overlays = {
+    dispose: () => {
+      if (overlays.origin) {
+        target.remove(overlays.origin);
+        disposeObjectResources(overlays.origin);
+      }
+      overlays.bounds?.forEach((bound) => {
+        target.remove(bound);
+        disposeObjectResources(bound);
+      });
+      overlays.sockets?.forEach((socket) => {
+        target.remove(socket);
+        disposeObjectResources(socket);
+      });
+      overlays.origin = void 0;
+      overlays.bounds = void 0;
+      overlays.sockets = void 0;
     }
-    return overlays;
+  };
+  if (options.origin) {
+    const origin = createOriginHelper(THREE, options);
+    overlays.origin = origin;
+    target.add(origin);
+  }
+  if (options.bounds && target.userData?.size) {
+    const bound = createBoundsHelper(THREE, target.userData.size, options);
+    overlays.bounds = [bound];
+    target.add(bound);
+  }
+  if (options.sockets && target.userData?.sockets) {
+    const sockets = target.userData.sockets.map((position) => {
+      const helper = createSocketHelper(THREE, options);
+      helper.position.set(position[0], position[1], position[2]);
+      target.add(helper);
+      return helper;
+    });
+    overlays.sockets = sockets;
+  }
+  return overlays;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  attachBoxelOverlays
+});

package/node_modules/@playdrop/boxel-three/dist/src/primitives.js

@@ -1,20 +1,48 @@
-export function createBoxGeometry(THREE, size) {
-    return new THREE.BoxGeometry(size[0], size[1], size[2]);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var primitives_exports = {};
+__export(primitives_exports, {
+  collectGroupVertexIndices: () => collectGroupVertexIndices,
+  createBoxGeometry: () => createBoxGeometry
+});
+module.exports = __toCommonJS(primitives_exports);
+function createBoxGeometry(THREE, size) {
+  return new THREE.BoxGeometry(size[0], size[1], size[2]);
 }
-export function collectGroupVertexIndices(geometry) {
-    const indexAttr = geometry.index;
-    const groups = geometry.groups;
-    if (!indexAttr || !groups || groups.length === 0) {
-        return [];
+function collectGroupVertexIndices(geometry) {
+  const indexAttr = geometry.index;
+  const groups = geometry.groups;
+  if (!indexAttr || !groups || groups.length === 0) {
+    return [];
+  }
+  const indices = indexAttr.array;
+  const result = [];
+  groups.forEach((group) => {
+    const set = /* @__PURE__ */ new Set();
+    for (let i = 0; i < group.count; i += 1) {
+      set.add(indices[group.start + i]);
     }
-    const indices = indexAttr.array;
-    const result = [];
-    groups.forEach(group => {
-        const set = new Set();
-        for (let i = 0; i < group.count; i += 1) {
-            set.add(indices[group.start + i]);
-        }
-        result.push(set);
-    });
-    return result;
+    result.push(set);
+  });
+  return result;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectGroupVertexIndices,
+  createBoxGeometry
+});