@archvisioninc/canvas 3.3.7 → 3.3.8

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(wc -l /c/Users/ArchVision/Documents/git/archvision-canvas/src/package/helpers/*.js)",
+      "Bash(npx eslint:*)"
+    ]
+  }
+}

package/README_DEV.md

@@ -30,7 +30,10 @@ You will need to be invited to the Archvision, Inc. team on [NPM](https://npmjs.
 
 Since the canvas package is under Archvision, Inc.  It will be identified as [@archvisioninc/canvas](https://npmjs.com/package/@archvisioninc/canvas).
 
-
+> npm has updated their packaging publishing process that may require the developer to add 2FA to their account.  Once this is added to the developer's account, they will need to run
+>> npm login
+>
+> to reauthenticate with the 2FA enabled.  This 2FA process will also be required when publishing a new version of canvas to npm. 
 
 ## Project structure and organization
 This project's main development environment is found in `/src`.  Each file and folder, except the `/src/package` folder,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archvisioninc/canvas",
-  "version": "3.3.7",
+  "version": "3.3.8",
   "private": false,
   "main": "dist/Canvas.js",
   "module": "dist/Canvas.js",

package/src/package/helpers/canvasUpdateHelpers.js

@@ -317,6 +317,85 @@ const dataUrlToBlob = dataURI => {
   return blob;
 };
 
+const getActiveAnimationGroup = animationGroups => {
+  const selectedAnimationIndex = scene.metadata?.selectedAnimation;
+
+  if (selectedAnimationIndex === null || selectedAnimationIndex === undefined) {
+    return null;
+  }
+
+  return animationGroups.find((_group, index) => {
+    return `${index}` === `${selectedAnimationIndex}`;
+  }) || null;
+};
+
+let animationSyncObserver = null;
+let lastAnimationSerializeAt = 0;
+const ANIMATION_SYNC_MS = 50;
+
+const pushAnimationStateToReact = () => {
+  const activeAnimationGroup = getActiveAnimationGroup(scene.animationGroups || []);
+
+  syncSelectedAnimationMeta(activeAnimationGroup);
+
+  const now = performance.now();
+  if (
+    props.setSerializedData
+    && now - lastAnimationSerializeAt >= ANIMATION_SYNC_MS
+  ) {
+    lastAnimationSerializeAt = now;
+    props.setSerializedData(serializeScene());
+  }
+};
+
+const ensureAnimationStateSync = () => {
+  if (animationSyncObserver || !scene?.onBeforeRenderObservable) {
+    return;
+  }
+
+  animationSyncObserver = scene.onBeforeRenderObservable.add(() => {
+    const activeAnimationGroup = getActiveAnimationGroup(scene.animationGroups || []);
+
+    if (!activeAnimationGroup) {
+      return;
+    }
+
+    pushAnimationStateToReact();
+  });
+};
+
+const syncSelectedAnimationMeta = animationGroup => {
+  if (!scene.metadata) return;
+
+  if (!animationGroup) {
+    scene.metadata.selectedAnimationTime = 0;
+    scene.metadata.selectedAnimationProgress = 0;
+    scene.metadata.selectedAnimationDuration = 0;
+    scene.metadata.selectedAnimationIsPlaying = false;
+    return;
+  }
+
+  const runtimeAnimation = animationGroup.animatables?.[0]?.getAnimations?.()?.[0];
+  const currentFrame = runtimeAnimation?.currentFrame ?? animationGroup.from ?? 0;
+  const from = animationGroup.from ?? 0;
+  const to = animationGroup.to ?? 0;
+  const totalFrames = Math.max(to - from, 1);
+
+  const progress = BABYLON.Scalar.Clamp(
+    (currentFrame - from) / totalFrames,
+    0,
+    1
+  );
+
+  const duration = animationGroup.getLength?.() ?? 0;
+
+  scene.metadata.selectedAnimationProgress = progress;
+  scene.metadata.selectedAnimationTime = progress * duration;
+  scene.metadata.selectedAnimationDuration = duration;
+  scene.metadata.selectedAnimationIsPlaying = Boolean(animationGroup.isPlaying);
+};
+
+
 export const updateMaterial = inboundData => {
   const { payload } = inboundData;
   const {
@@ -669,6 +748,10 @@ export const updateMesh = inboundData => {
     animationId,
     resetAnimation,
     loopAnimation = true,
+    playAnimation,
+    pauseAnimation,
+    seekAnimation,
+    animationProgress,
     sourceUnit,
     displayUnit,
   } = payload;
@@ -790,6 +873,8 @@ export const updateMesh = inboundData => {
   if (resetAnimation) {
     stopAllAnimationGroups();
     newMetaDataEntry('selectedAnimation', null);
+    syncSelectedAnimationMeta(null);
+    props.setSerializedData?.(serializeScene());
   }
 
   // Change active animation
@@ -801,9 +886,38 @@ export const updateMesh = inboundData => {
     if (animationGroup) {
       animationGroup.start(Boolean(loopAnimation));
       newMetaDataEntry('selectedAnimation', `${animationId}`);
+      syncSelectedAnimationMeta(animationGroup);
+      ensureAnimationStateSync();
+      props.setSerializedData?.(serializeScene());
     }
   }
 
+  const activeAnimationGroup = getActiveAnimationGroup(animationGroups);
+
+  // Play current animation
+  if (playAnimation && activeAnimationGroup) {
+    activeAnimationGroup.play(Boolean(loopAnimation));
+    syncSelectedAnimationMeta(activeAnimationGroup);
+    ensureAnimationStateSync();
+    props.setSerializedData?.(serializeScene());
+  }
+
+  // Pause current animation
+  if (pauseAnimation && activeAnimationGroup) {
+    activeAnimationGroup.pause();
+    syncSelectedAnimationMeta(activeAnimationGroup);
+    props.setSerializedData?.(serializeScene());
+  }
+
+  // Seek current animation to a progress position (0–1)
+  if (seekAnimation && activeAnimationGroup && animationProgress !== undefined) {
+    const { from, to } = activeAnimationGroup;
+    const frame = from + animationProgress * (to - from);
+    activeAnimationGroup.goToFrame(frame);
+    syncSelectedAnimationMeta(activeAnimationGroup);
+    props.setSerializedData?.(serializeScene());
+  }
+
   // Bounding Box Toggle
   if (boundingBoxEnabled !== undefined) {
     toggleBoundingBoxWidget();

package/dist/Canvas.js

@@ -1,67 +0,0 @@
-import _ from 'lodash';
-import React, { useRef, useEffect, useCallback } from 'react';
-import { initScene, cleanup, createScene, engine, scene, warningChecks, updateItem, getGLTFData, takePreviewScreenshots } from './helpers';
-import { CanvasContainer, RenderCanvas } from './styles';
-export let reactProps;
-const Canvas = props => {
-  const {
-    file,
-    guidURL,
-    reinitialize,
-    updateData,
-    exportModel,
-    toDownload,
-    exportType
-  } = props;
-  const canvasRef = useRef();
-  const checkForWarnings = useCallback(() => {
-    if (scene) {
-      const hasPlugin = scene?.loadingPluginName;
-      if (hasPlugin) warningChecks();
-    }
-  }, []);
-  useEffect(() => {
-    return () => {
-      cleanup();
-    };
-  }, []);
-  useEffect(() => {
-    initScene({
-      canvasRef
-    });
-  }, [canvasRef, guidURL]);
-  useEffect(() => {
-    reactProps = props;
-  }, [props]);
-  useEffect(() => {
-    const createNewScene = true;
-    if (file || guidURL && engine) createScene();
-    if (!file && !guidURL && scene) createScene(createNewScene);
-  }, [file, guidURL]);
-  useEffect(() => {
-    checkForWarnings();
-  }, [checkForWarnings]);
-  useEffect(() => {
-    if (scene && !_.isEmpty(updateData)) {
-      updateItem(updateData);
-    }
-  }, [updateData]);
-  useEffect(() => {
-    if (canvasRef && reinitialize) {
-      cleanup();
-      initScene({
-        canvasRef
-      });
-    }
-  }, [canvasRef, reinitialize]);
-  useEffect(() => {
-    if (exportModel && exportType) {
-      getGLTFData(exportType, toDownload);
-      takePreviewScreenshots();
-    }
-  }, [exportModel, exportType, toDownload]);
-  return /*#__PURE__*/React.createElement(CanvasContainer, props, /*#__PURE__*/React.createElement(RenderCanvas, {
-    ref: canvasRef
-  }));
-};
-export default Canvas;

package/dist/actions/index.js

@@ -1 +0,0 @@
-export * from './shortcutActions';

package/dist/actions/shortcutActions.js

@@ -1,313 +0,0 @@
-import * as BABYLON from 'babylonjs';
-import * as BABYLONGUI from 'babylonjs-gui';
-import { getUserMeshes, gizmoManager, newFraming, scene, selectedMeshes, theme, $selectedTheme, newColor, toggleCameraMode, getParamOfSelectedMeshes, getUserMaterials, guiTexture, getBoundingMeshData, singleMeshTNode, multiMeshTNode, createBoundingMesh, restoreParents, createSafeFrame, newMetaDataEntry, resetSelectedMeshes, buildMaterialsArray, buildSelectedMaterialArray, addAutoRotation, removeAutoRotation, autoRotation, buildMeshPositionsArray } from '../helpers';
-import { GIZMOS, GUI, MESH_PARAMS } from '../constants';
-import { exclusionMaterials, orthoOptions, dimensions, scaleUnits } from '../enums';
-import _ from 'lodash';
-export let cameraView;
-export const resetManagerGizmos = type => {
-  Object.values(GIZMOS).forEach(value => {
-    if (value !== type) {
-      const propertyName = _.camelCase(`${value}Enabled`);
-      gizmoManager[propertyName] = false;
-    }
-  });
-  dimensions.forEach(dimension => {
-    guiTexture.getControlByName(dimension.rectangle)?.dispose?.();
-    guiTexture.getControlByName(dimension.label)?.dispose?.();
-    guiTexture.getControlByName(dimension.container)?.dispose?.();
-  });
-  switch (selectedMeshes.length) {
-    case 1:
-      gizmoManager.attachToNode(singleMeshTNode);
-      break;
-    default:
-      gizmoManager.attachToNode(multiMeshTNode);
-      break;
-  }
-};
-export const toggleTurntable = override => {
-  const camera = scene.activeCamera;
-  const rotationEnabled = camera.useAutoRotationBehavior;
-  if (!autoRotation) addAutoRotation();
-  if (override !== undefined) {
-    camera.useAutoRotationBehavior = override;
-    if (override) {
-      autoRotation.attach(camera);
-      autoRotation.idleRotationSpeed = -0.1;
-      return;
-    }
-    autoRotation.detach(camera);
-    removeAutoRotation();
-    return;
-  }
-  if (rotationEnabled) {
-    autoRotation.detach(camera);
-    camera.useAutoRotationBehavior = false;
-    removeAutoRotation();
-    return;
-  }
-  autoRotation.attach(camera);
-  camera.useAutoRotationBehavior = true;
-  autoRotation.idleRotationSpeed = -0.1;
-};
-export const focusCamera = () => {
-  const camera = scene.activeCamera;
-  const userMeshes = getUserMeshes();
-  const framingBehavior = newFraming();
-  const babylonOrthographic = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
-  const isOrtho = camera.mode === babylonOrthographic;
-  const boundingMesh = scene.getMeshById('boundingMesh');
-  const meshCenter = getParamOfSelectedMeshes(MESH_PARAMS.center);
-  const framingMeshes = boundingMesh ? [boundingMesh] : userMeshes;
-  framingBehavior.framingTime = 0;
-  framingBehavior.defaultElevation = 0;
-  framingBehavior.attach?.(camera);
-  !_.isEmpty(userMeshes) ? framingBehavior.zoomOnMeshesHierarchy(framingMeshes) : camera.setTarget(BABYLON.Vector3.Zero());
-  camera.beta = Math.PI / 2;
-  if (isOrtho) {
-    camera.target = meshCenter;
-    camera.alpha = orthoOptions[cameraView].alpha;
-    camera.beta = orthoOptions[cameraView].beta;
-  }
-  framingBehavior.detach?.(camera);
-};
-export const toggleSafeFrame = (e, aspectRatio, override) => {
-  let outerFrame = guiTexture.getControlByName(GUI.outerSafeFrame);
-  if (aspectRatio) {
-    outerFrame?.dispose();
-    createSafeFrame(aspectRatio);
-    outerFrame = guiTexture.getControlByName(GUI.outerSafeFrame);
-    outerFrame.isVisible = override;
-    newMetaDataEntry('safeFrameEnabled', outerFrame.isVisible);
-    return;
-  }
-  if (override === undefined && outerFrame) {
-    outerFrame.isVisible = !outerFrame.isVisible;
-    newMetaDataEntry('safeFrameEnabled', outerFrame.isVisible);
-    return;
-  }
-};
-export const toggleInspector = () => {
-  const inspector = scene.debugLayer;
-  inspector.isVisible() ? inspector.hide() : inspector.show();
-};
-export const toggleMoveWidget = () => {
-  if (!_.isEmpty(selectedMeshes)) {
-    resetManagerGizmos(GIZMOS.PositionGizmo);
-    gizmoManager.positionGizmoEnabled = !gizmoManager.positionGizmoEnabled;
-  }
-};
-export const toggleRotateWidget = () => {
-  if (!_.isEmpty(selectedMeshes)) {
-    resetManagerGizmos(GIZMOS.RotationGizmo);
-    gizmoManager.rotationGizmoEnabled = !gizmoManager.rotationGizmoEnabled;
-  }
-};
-export const toggleScaleWidget = () => {
-  if (!_.isEmpty(selectedMeshes)) {
-    resetManagerGizmos(GIZMOS.ScaleGizmo);
-    gizmoManager.scaleGizmoEnabled = !gizmoManager.scaleGizmoEnabled;
-  }
-};
-export const toggleBoundingBoxWidget = () => {
-  const boundingMesh = scene.getMeshById('boundingMesh');
-  const boxColor = newColor(theme.colors[$selectedTheme].accent);
-  const isEnabled = gizmoManager.boundingBoxGizmoEnabled;
-  const boundingInfo = getBoundingMeshData([boundingMesh]);
-  dimensions.forEach(dimension => {
-    guiTexture.getControlByName(dimension.rectangle)?.dispose?.();
-    guiTexture.getControlByName(dimension.label)?.dispose?.();
-    guiTexture.getControlByName(dimension.container)?.dispose?.();
-  });
-  if (!gizmoManager.boundingBoxGizmoEnabled) {
-    resetManagerGizmos(GIZMOS.BoundingBoxGizmo);
-    gizmoManager.attachToMesh(boundingMesh);
-  }
-  gizmoManager.boundingBoxGizmoEnabled = !isEnabled;
-  gizmoManager.boundingBoxDragBehavior.rotateDraggedObject = false;
-  gizmoManager.boundingBoxDragBehavior.disableMovement = true;
-  gizmoManager.gizmos.boundingBoxGizmo.setEnabledScaling(false);
-  gizmoManager.gizmos.boundingBoxGizmo.setEnabledRotationAxis('');
-  gizmoManager.gizmos.boundingBoxGizmo.setColor(boxColor);
-  newMetaDataEntry('boundingBoxEnabled', !isEnabled);
-
-  // ================ Bounding Box Labels ================
-  const buildUnitLabel = dimension => {
-    const {
-      name,
-      color,
-      label,
-      rectangle,
-      container
-    } = dimension;
-    const {
-      center,
-      minimum,
-      maximumWorld,
-      minimumWorld
-    } = boundingInfo;
-    const displayUnit = scene.metadata?.selectedDisplayUnit || scene.metadata?.selectedSourceUnit;
-    const labelHeight = 36;
-    let x, y, z, value;
-    const buildValue = axis => {
-      const workingValue = Math.abs(minimumWorld[axis] - maximumWorld[axis]);
-      const meterScaleFactor = scaleUnits.find(unit => unit.abbreviation === 'm').scaleFactor;
-      const displayScaleFactor = scaleUnits.find(unit => unit.abbreviation === displayUnit || unit.name === displayUnit)?.scaleFactor || meterScaleFactor;
-      return (workingValue / displayScaleFactor).toFixed(6);
-    };
-    switch (name) {
-      case 'length':
-        x = center.x + (maximumWorld.x - minimumWorld.x) / 2;
-        y = center.y - Math.abs(minimum.y);
-        z = center.z;
-        value = buildValue('z');
-        break;
-      case 'width':
-        x = center.x;
-        y = center.y - Math.abs(minimum.y);
-        z = center.z + (maximumWorld.z - minimumWorld.z) / 2;
-        value = buildValue('x');
-        break;
-      default:
-        x = center.x + (maximumWorld.x - minimumWorld.x) / 2;
-        y = center.y;
-        z = center.z + (maximumWorld.z - minimumWorld.z) / 2;
-        value = buildValue('y');
-    }
-    const lengthPosition = new BABYLON.Vector3(x, y, z);
-    const labelRectangle = new BABYLONGUI.Rectangle(rectangle);
-    labelRectangle.width = displayUnit ? 0.14 : 0.12;
-    labelRectangle.heightInPixels = labelHeight;
-    labelRectangle.cornerRadius = 3;
-    labelRectangle.color = color;
-    labelRectangle.thickness = 1;
-    labelRectangle.background = color + 20;
-    guiTexture.addControl(labelRectangle);
-    const lengthLabel = new BABYLONGUI.TextBlock(label);
-    lengthLabel.text = `${_.startCase(name)}: ${value}${displayUnit || ''}`;
-    labelRectangle.addControl(lengthLabel);
-    const labelLinkBox = BABYLON.MeshBuilder.CreateBox(container, scene);
-    labelLinkBox.position = lengthPosition;
-    labelLinkBox.isPickable = false;
-    labelLinkBox.visibility = 0;
-    labelLinkBox.setParent(boundingMesh);
-    labelRectangle.linkWithMesh(labelLinkBox);
-    labelRectangle.linkOffsetX = 30;
-    labelRectangle.linkOffsetY = 30;
-  };
-  if (gizmoManager.boundingBoxGizmoEnabled) {
-    dimensions.forEach(dimension => buildUnitLabel(dimension));
-  }
-};
-export const hideSelected = () => {
-  selectedMeshes.forEach(mesh => {
-    mesh.isVisible = false;
-  });
-  resetManagerGizmos();
-};
-export const unhideAll = () => {
-  scene.meshes.forEach(mesh => {
-    if (!mesh.isVisible) {
-      mesh.isVisible = true;
-    }
-  });
-};
-export const deleteSelected = () => {
-  selectedMeshes.forEach(mesh => {
-    const material = mesh.material;
-    if (material?.getBindedMeshes().length === 1) {
-      const subMaterials = material.subMaterials;
-      const defaultMaterial = name => exclusionMaterials.includes(name);
-      if (subMaterials) {
-        subMaterials?.forEach(subMaterial => !defaultMaterial(subMaterial.name) && subMaterial.dispose());
-      }
-      if (!defaultMaterial(material.name)) material.dispose();
-      material.getActiveTextures().forEach(texture => texture.dispose());
-    }
-    resetManagerGizmos();
-    mesh.dispose();
-  });
-  resetSelectedMeshes();
-};
-export const toggleOrthographicViews = (e, orthoCamera) => {
-  const isDifferent = cameraView !== orthoCamera;
-  const babylonOrthographic = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
-  const babylonPerspective = BABYLON.Camera.PERSPECTIVE_CAMERA;
-  if (scene?.debugLayer.isVisible()) return;
-  if (isDifferent) {
-    cameraView = orthoCamera;
-    toggleCameraMode(orthoCamera, babylonOrthographic);
-    newMetaDataEntry('selectedOrthoView', orthoCamera);
-    return;
-  }
-  toggleCameraMode(orthoCamera, babylonPerspective);
-  newMetaDataEntry('selectedOrthoView', '');
-  cameraView = null;
-};
-export const toggleCulling = () => {
-  const materials = getUserMaterials();
-  materials.forEach(material => {
-    const isCullingBackfaces = material.backFaceCulling;
-    if (isCullingBackfaces) return material.backFaceCulling = false;
-    material.backFaceCulling = !material.backFaceCulling;
-  });
-  newMetaDataEntry('materials', buildMaterialsArray());
-  newMetaDataEntry('selectedMaterials', buildSelectedMaterialArray());
-};
-export const modelToOrigin = sourceUnitScaleOperation => {
-  const boundingBoxEnabled = gizmoManager.boundingBoxGizmoEnabled;
-  const meshes = selectedMeshes.length > 0 ? selectedMeshes : getUserMeshes();
-  const parentList = [];
-  const handleBoundingBox = () => {
-    const newBox = createBoundingMesh();
-    if (boundingBoxEnabled && !sourceUnitScaleOperation) toggleBoundingBoxWidget();
-    if (gizmoManager.boundingBoxGizmoEnabled) gizmoManager.attachToMesh(newBox);
-    resetManagerGizmos(GIZMOS.BoundingBoxGizmo);
-  };
-
-  // Single selections or only single mesh in scene.
-  if (meshes.length === 1) {
-    const mesh = meshes[0];
-    const boundingBox = mesh.getBoundingInfo().boundingBox;
-    const meshCenter = boundingBox.centerWorld;
-    const parent = mesh.parent;
-    parentList.push({
-      mesh,
-      parent
-    });
-    mesh.setParent(singleMeshTNode);
-    singleMeshTNode.position.subtractInPlace(meshCenter);
-    singleMeshTNode.position.y += boundingBox.extendSizeWorld.y;
-    selectedMeshes.length === 1 ? mesh.setParent(singleMeshTNode) : restoreParents(parentList);
-    handleBoundingBox();
-    newMetaDataEntry('meshChangeTracking', buildMeshPositionsArray({
-      preserveScale: true,
-      preserveRotation: true
-    }));
-    return;
-  }
-
-  // Multiple selections or multiple meshes in scene.
-  const multiBoundingData = getBoundingMeshData(meshes);
-  const boundingCenter = multiBoundingData.center;
-  const compensationY = multiBoundingData.maximum.y - boundingCenter.y;
-  meshes.forEach(mesh => {
-    const parent = mesh.parent;
-    parentList.push({
-      mesh,
-      parent
-    });
-    mesh.setParent(multiMeshTNode);
-  });
-  if (!sourceUnitScaleOperation) {
-    multiMeshTNode.position.subtractInPlace(boundingCenter);
-    multiMeshTNode.position.y += compensationY;
-  }
-  restoreParents(parentList);
-  handleBoundingBox();
-  newMetaDataEntry('meshChangeTracking', buildMeshPositionsArray({
-    preserveScale: true,
-    preserveRotation: true
-  }));
-};

package/dist/constants/constants.js

@@ -1,80 +0,0 @@
-export const TEXTURE_SIZE_THRESHOLD = 4096;
-export const MATERIAL_COUNT_THRESHOLD = 50;
-export const MESH_COUNT_THRESHOLD = 500;
-export const INSPECTOR = {
-  root: '__root__'
-};
-export const LISTENERS = {
-  resize: 'resize',
-  keyup: 'keyup'
-};
-export const LIGHTS = {
-  SpotLight: 'SpotLight',
-  ShadowGenerator: 'ShadowGenerator',
-  PointLight: 'PointLight',
-  DirectionalLight: 'DirectionalLight',
-  HemisphericLight: 'HemisphericLight',
-  GroundLight: 'GroundLight'
-};
-export const CAMERAS = {
-  FreeCamera: 'FreeCamera',
-  FlyCamera: 'FlyCamera',
-  FollowCamera: 'FollowCamera',
-  GamepadCamera: 'GamepadCamera',
-  TouchCamera: 'TouchCamera',
-  UniversalCamera: 'UniversalCamera',
-  ArcRotateCamera: 'ArcRotateCamera'
-};
-export const VIEWPORT = {
-  shadowMapSize: 4096
-};
-export const GIZMOS = {
-  RotationGizmo: 'RotationGizmo',
-  PositionGizmo: 'PositionGizmo',
-  ScaleGizmo: 'ScaleGizmo',
-  BoundingBoxGizmo: 'BoundingBoxGizmo'
-};
-export const ORTHO = {
-  left: 'orthoLeft',
-  right: 'orthoRight',
-  top: 'orthoTop',
-  bottom: 'orthoBottom'
-};
-export const GUI = {
-  dragSelectBox: 'dragSelectBox',
-  innerSafeFrame: 'safeFrame_inner',
-  outerSafeFrame: 'safeFrame_outer'
-};
-export const MESH_PARAMS = {
-  center: 'center',
-  rotation: 'rotation',
-  scaling: 'scaling',
-  radius: 'radius'
-};
-export const MESSAGE_TYPES = {
-  error: 'error',
-  warning: 'warning',
-  info: 'info',
-  success: 'success',
-  loading: 'loading'
-};
-export const UPDATABLE_ITEMS = {
-  material: 'material',
-  mesh: 'mesh',
-  camera: 'camera',
-  environment: 'environment',
-  texture: 'texture',
-  viewport: 'viewport',
-  publish: 'publish',
-  lighting: 'lighting'
-};
-export const TRANSPARENCY_MODES = {
-  simple: 'simple',
-  complex: 'complex',
-  stencil: 'stencil'
-};
-export const AXIS_COLORS = {
-  xAxis: '#EA4231',
-  yAxis: '#249C4A',
-  zAxis: '#0089EA'
-};

package/dist/constants/index.js

@@ -1 +0,0 @@
-export * from './constants';

package/dist/enums/aspectRatios.js

@@ -1,17 +0,0 @@
-export const ratios = {
-  square: {
-    name: 'square',
-    label: '1:1',
-    value: 1
-  },
-  broadcast: {
-    name: 'broadcast',
-    label: '4:3',
-    value: 1.33
-  },
-  cinema: {
-    name: 'cinema',
-    label: '16:9',
-    value: 1.77
-  }
-};

package/dist/enums/dimensions.js

@@ -1,20 +0,0 @@
-import { AXIS_COLORS } from '../constants';
-export const dimensions = [{
-  name: 'length',
-  color: AXIS_COLORS.zAxis,
-  rectangle: 'lengthRectangle',
-  label: 'lengthLabel',
-  container: 'lengthContainer'
-}, {
-  name: 'height',
-  color: AXIS_COLORS.yAxis,
-  rectangle: 'heightRectangle',
-  label: 'heightLabel',
-  container: 'widthContainer'
-}, {
-  name: 'width',
-  color: AXIS_COLORS.xAxis,
-  rectangle: 'widthRectangle',
-  label: 'widthLabel',
-  container: 'heightContainer'
-}];

package/dist/enums/downscaling.js

@@ -1,16 +0,0 @@
-export const downscaling = [{
-  name: '4K',
-  value: 4096
-}, {
-  name: '2K',
-  value: 2048
-}, {
-  name: '1K',
-  value: 1024
-}, {
-  name: '512',
-  value: 512
-}, {
-  name: '256',
-  value: 256
-}];