@pretty-chitty/core 1.1.2 → 1.2.1

package/src/library/utilities/GlbLoader.ts

@@ -0,0 +1,292 @@
+import {
+  BufferGeometry,
+  BufferAttribute,
+  Group,
+  Mesh,
+  MeshStandardMaterial,
+  Matrix4,
+  Color,
+} from "three";
+import QuickLRU from "quick-lru";
+
+// ── glTF JSON types (subset we care about) ──────────────────────────────
+
+interface GltfJson {
+  scene?: number;
+  scenes?: Array<{ nodes?: number[] }>;
+  nodes?: Array<{
+    mesh?: number;
+    children?: number[];
+    name?: string;
+    translation?: [number, number, number];
+    rotation?: [number, number, number, number];
+    scale?: [number, number, number];
+    matrix?: number[];
+  }>;
+  meshes?: Array<{
+    name?: string;
+    primitives: Array<{
+      attributes: Record<string, number>;
+      indices?: number;
+      material?: number;
+    }>;
+  }>;
+  accessors?: Array<{
+    bufferView?: number;
+    byteOffset?: number;
+    componentType: number;
+    count: number;
+    type: string;
+  }>;
+  bufferViews?: Array<{
+    buffer: number;
+    byteOffset?: number;
+    byteLength: number;
+    byteStride?: number;
+  }>;
+  materials?: Array<{
+    name?: string;
+    doubleSided?: boolean;
+    pbrMetallicRoughness?: {
+      baseColorFactor?: [number, number, number, number];
+      metallicFactor?: number;
+      roughnessFactor?: number;
+    };
+  }>;
+}
+
+// ── Constants ───────────────────────────────────────────────────────────
+
+const COMPONENT_TYPES: Record<number, { ctor: new (buffer: ArrayBuffer, byteOffset: number, length: number) => ArrayLike<number>; bytes: number }> = {
+  5120: { ctor: Int8Array, bytes: 1 },
+  5121: { ctor: Uint8Array, bytes: 1 },
+  5122: { ctor: Int16Array, bytes: 2 },
+  5123: { ctor: Uint16Array, bytes: 2 },
+  5125: { ctor: Uint32Array, bytes: 4 },
+  5126: { ctor: Float32Array, bytes: 4 },
+};
+
+const TYPE_SIZES: Record<string, number> = {
+  SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16,
+};
+
+// ── Module-level caches ─────────────────────────────────────────────────
+
+const groupCache = new QuickLRU<string, Group>({ maxSize: 50 });
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+function hashString(s: string): string {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = ((h << 5) + h) ^ s.charCodeAt(i);
+  return (h >>> 0).toString(36);
+}
+
+function decodeToArrayBuffer(dataUrl: string): ArrayBuffer {
+  const commaIndex = dataUrl.indexOf(",");
+  const base64 = commaIndex !== -1 ? dataUrl.slice(commaIndex + 1) : dataUrl;
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes.buffer;
+}
+
+// ── GLB container parser ────────────────────────────────────────────────
+
+function parseGLBContainer(buffer: ArrayBuffer): { json: GltfJson; bin: ArrayBuffer } {
+  const view = new DataView(buffer);
+  const magic = view.getUint32(0, true);
+  if (magic !== 0x46546C67) throw new Error("Not a valid GLB file");
+  const version = view.getUint32(4, true);
+  if (version !== 2) throw new Error(`Unsupported glTF version: ${version}`);
+
+  let offset = 12;
+  let json: GltfJson | undefined;
+  let bin: ArrayBuffer | undefined;
+
+  while (offset < buffer.byteLength) {
+    const chunkLength = view.getUint32(offset, true);
+    const chunkType = view.getUint32(offset + 4, true);
+    const chunkData = buffer.slice(offset + 8, offset + 8 + chunkLength);
+    if (chunkType === 0x4E4F534A) {
+      json = JSON.parse(new TextDecoder().decode(chunkData));
+    } else if (chunkType === 0x004E4942) {
+      bin = chunkData;
+    }
+    offset += 8 + chunkLength;
+  }
+
+  if (!json) throw new Error("GLB missing JSON chunk");
+  return { json, bin: bin ?? new ArrayBuffer(0) };
+}
+
+// ── Accessor → TypedArray ───────────────────────────────────────────────
+
+function readAccessor(json: GltfJson, bin: ArrayBuffer, idx: number): { array: ArrayLike<number>; itemSize: number } {
+  const acc = json.accessors![idx];
+  const bv = json.bufferViews![acc.bufferView ?? 0];
+  const info = COMPONENT_TYPES[acc.componentType];
+  if (!info) throw new Error(`Unsupported accessor componentType ${acc.componentType}`);
+
+  const itemSize = TYPE_SIZES[acc.type];
+  const byteOffset = (bv.byteOffset ?? 0) + (acc.byteOffset ?? 0);
+  const totalElements = acc.count * itemSize;
+
+  // Non-interleaved (or tightly packed): direct view
+  if (!bv.byteStride || bv.byteStride === itemSize * info.bytes) {
+    return { array: new info.ctor(bin, byteOffset, totalElements), itemSize };
+  }
+
+  // Interleaved: de-stride into a contiguous array
+  const out = new Float32Array(totalElements);
+  const stride = bv.byteStride;
+  const srcView = new DataView(bin);
+  for (let i = 0; i < acc.count; i++) {
+    const base = byteOffset + i * stride;
+    for (let c = 0; c < itemSize; c++) {
+      out[i * itemSize + c] = srcView.getFloat32(base + c * info.bytes, true);
+    }
+  }
+  return { array: out, itemSize };
+}
+
+// ── Build Three.js objects ──────────────────────────────────────────────
+
+type GltfPrimitive = NonNullable<GltfJson["meshes"]>[0]["primitives"][0];
+
+function buildGeometry(json: GltfJson, bin: ArrayBuffer, prim: GltfPrimitive): BufferGeometry {
+  const geom = new BufferGeometry();
+
+  const ATTR_MAP: Record<string, string> = {
+    POSITION: "position",
+    NORMAL: "normal",
+    TEXCOORD_0: "uv",
+    TEXCOORD_1: "uv2",
+    COLOR_0: "color",
+    TANGENT: "tangent",
+  };
+
+  for (const [gltfName, accIdx] of Object.entries(prim.attributes)) {
+    const threeAttr = ATTR_MAP[gltfName];
+    if (!threeAttr) continue;
+    const { array, itemSize } = readAccessor(json, bin, accIdx as number);
+    geom.setAttribute(threeAttr, new BufferAttribute(new Float32Array(array as ArrayLike<number>), itemSize));
+  }
+
+  if (prim.indices !== undefined) {
+    const { array } = readAccessor(json, bin, prim.indices);
+    geom.setIndex(new BufferAttribute(
+      array instanceof Uint32Array ? array : new Uint32Array(array as ArrayLike<number>),
+      1,
+    ));
+  }
+
+  if (!geom.getAttribute("normal")) {
+    geom.computeVertexNormals();
+  }
+
+  return geom;
+}
+
+function buildMaterial(json: GltfJson, matIdx: number | undefined): MeshStandardMaterial {
+  const mat = new MeshStandardMaterial();
+  if (matIdx === undefined || !json.materials?.[matIdx]) return mat;
+
+  const def = json.materials[matIdx];
+  const pbr = def.pbrMetallicRoughness;
+  if (pbr) {
+    if (pbr.baseColorFactor) {
+      mat.color = new Color(pbr.baseColorFactor[0], pbr.baseColorFactor[1], pbr.baseColorFactor[2]);
+      mat.opacity = pbr.baseColorFactor[3];
+      if (mat.opacity < 1) mat.transparent = true;
+    }
+    if (pbr.metallicFactor !== undefined) mat.metalness = pbr.metallicFactor;
+    if (pbr.roughnessFactor !== undefined) mat.roughness = pbr.roughnessFactor;
+  }
+  if (def.doubleSided) mat.side = 2; // DoubleSide
+
+  return mat;
+}
+
+function buildNode(json: GltfJson, bin: ArrayBuffer, nodeIdx: number): Group | Mesh {
+  const nodeDef = json.nodes![nodeIdx];
+  const group = new Group();
+  if (nodeDef.name) group.name = nodeDef.name;
+
+  // Apply transform
+  if (nodeDef.matrix) {
+    const m = new Matrix4();
+    m.fromArray(nodeDef.matrix);
+    m.decompose(group.position, group.quaternion, group.scale);
+  } else {
+    if (nodeDef.translation) group.position.fromArray(nodeDef.translation);
+    if (nodeDef.rotation) group.quaternion.set(nodeDef.rotation[0], nodeDef.rotation[1], nodeDef.rotation[2], nodeDef.rotation[3]);
+    if (nodeDef.scale) group.scale.fromArray(nodeDef.scale);
+  }
+
+  // Attach mesh primitives
+  if (nodeDef.mesh !== undefined && json.meshes) {
+    const meshDef = json.meshes[nodeDef.mesh];
+    for (const prim of meshDef.primitives) {
+      const geom = buildGeometry(json, bin, prim);
+      const mat = buildMaterial(json, prim.material);
+      const mesh = new Mesh(geom, mat);
+      if (meshDef.name) mesh.name = meshDef.name;
+      group.add(mesh);
+    }
+  }
+
+  // Recurse children
+  if (nodeDef.children) {
+    for (const childIdx of nodeDef.children) {
+      group.add(buildNode(json, bin, childIdx));
+    }
+  }
+
+  return group;
+}
+
+function buildScene(json: GltfJson, bin: ArrayBuffer): Group {
+  const root = new Group();
+  const sceneDef = json.scenes?.[json.scene ?? 0];
+  if (sceneDef?.nodes) {
+    for (const nodeIdx of sceneDef.nodes) {
+      root.add(buildNode(json, bin, nodeIdx));
+    }
+  }
+  return root;
+}
+
+// ── Public API ──────────────────────────────────────────────────────────
+
+/**
+ * Synchronously load a GLB file (provided as a base64 data-URL from webpack
+ * asset/inline) and return a cloned scene Group.
+ *
+ * Parses the GLB binary directly (no async GLTFLoader). The parsed scene is
+ * memoized — subsequent calls return `.clone()`, giving each caller an
+ * independent object hierarchy while sharing BufferGeometry and Material data.
+ */
+export function loadGLB(
+  glbData: string,
+  { scale = 1, castShadow = false, receiveShadow = false }: { scale?: number; castShadow?: boolean; receiveShadow?: boolean } = {},
+): Group {
+  const key = `${hashString(glbData)}|s:${scale}|cs:${castShadow ? 1 : 0}|rs:${receiveShadow ? 1 : 0}`;
+
+  let cached = groupCache.get(key);
+  if (!cached) {
+    const buffer = decodeToArrayBuffer(glbData);
+    const { json, bin } = parseGLBContainer(buffer);
+    cached = buildScene(json, bin);
+    cached.traverse((obj) => {
+      if ((obj as Mesh).isMesh) {
+        if (scale !== 1) (obj as Mesh).geometry.scale(scale, scale, scale);
+        obj.castShadow = castShadow;
+        obj.receiveShadow = receiveShadow;
+      }
+    });
+    groupCache.set(key, cached);
+  }
+
+  return cached.clone();
+}

package/src/library/utilities/LayoutHelper.ts

@@ -161,7 +161,10 @@ function buildValidTree(tree: LayoutNode, width: number, height: number): Concre
   }
 
   // Step 3: Scan ENTIRE tree for the container with smallest collapseOrder
-  const toCollapse = findSmallestCollapseOrder(concreteTree);
+  let toCollapse = findSmallestCollapseOrder(concreteTree);
+  if (!toCollapse) {
+    toCollapse = findSmallestCollapseOrderIgnoringConstraints(concreteTree);
+  }
 
   if (!toCollapse) {
     return concreteTree;
@@ -345,7 +348,7 @@ function findSmallestCollapseOrder(node: ConcreteLayoutNode): ContainerNode | nu
   }
 
   const container = node as ConcreteContainerNode;
-  let smallest: ContainerNode | null = container.collapseOrder !== undefined ? container : null;
+  let smallest: ContainerNode | null = null;
 
   for (const split of container.splits) {
     const childSmallest = findSmallestCollapseOrder(split);
@@ -362,6 +365,29 @@ function findSmallestCollapseOrder(node: ConcreteLayoutNode): ContainerNode | nu
   return smallest;
 }
 
+function findSmallestCollapseOrderIgnoringConstraints(node: ConcreteLayoutNode): ContainerNode | null {
+  if (isPanelNode(node) || isCollapsedNode(node)) {
+    return null;
+  }
+
+  const container = node as ConcreteContainerNode;
+  let smallest: ContainerNode | null = node.collapseOrder !== undefined ? container : null;
+
+  for (const split of container.splits) {
+    const childSmallest = findSmallestCollapseOrderIgnoringConstraints(split);
+    if (childSmallest) {
+      const childOrder = childSmallest.collapseOrder ?? Number.MAX_SAFE_INTEGER;
+      const currentOrder = smallest?.collapseOrder ?? Number.MAX_SAFE_INTEGER;
+
+      if (childOrder < currentOrder) {
+        smallest = childSmallest;
+      }
+    }
+  }
+
+  return smallest;
+}
+
 /**
  * Flattens a valid ConcreteLayoutNode tree into PanelLayoutResult[]
  */

package/src/library/utilities/ObjectWithProps.ts

@@ -1,13 +1,37 @@
 import "reflect-metadata";
-import nextTick from "next-tick";
 import { checkAnnotation, NonEditable } from "./Annotations";
 
 const CATCH_ALL = "[[null]]";
 export class ObjectWithProps {
+  /** @internal */
+  @NonEditable private _propsArray: string[] = [];
+  /** @internal */
+  @NonEditable private _propsSet = new Set<string>();
+
   /** @internal */
   public get props(): string[] {
-    return Object.keys(this).filter((key) => !checkAnnotation(this, key, NonEditable));
+    const props = Object.keys(this).filter((key) => !checkAnnotation(this, key, NonEditable));
+    props.forEach((key) => {
+      if (!this._propsSet.has(key)) {
+        this._propsSet.add(key);
+        this._propsArray.push(key);
+      }
+    });
+    return this._propsArray;
   }
+
+  /** @internal */
+  public expandedPropsFromJson(json: { [key: string]: unknown }): string[] {
+    this.props; // make sure this runs.
+    for (const key of Object.keys(json)) {
+      if (!this._propsSet!.has(key) && !checkAnnotation(this, key, NonEditable)) {
+        this._propsSet!.add(key);
+        this._propsArray!.push(key);
+      }
+    }
+    return this._propsArray;
+  }
+
   /** @internal */
   @NonEditable private _cbs: { [key: string]: Array<() => void> } = {};
 
@@ -22,7 +46,7 @@ export class ObjectWithProps {
   /** @internal */
   public notifyChange(key: string): void {
     if (this._keysThatChanged.size === 0) {
-      nextTick(() => {
+      queueMicrotask(() => {
         this._keysThatChanged.forEach((key) => this._cbs[key]?.forEach((cb) => cb()));
         this._cbs[CATCH_ALL]?.forEach((cb) => cb());
         this._keysThatChanged.clear();

package/dist/components/GalleryDisplay.d.ts

@@ -1,2 +0,0 @@
-export declare function GalleryDisplay(): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=GalleryDisplay.d.ts.map

package/dist/components/GalleryDisplay.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GalleryDisplay.d.ts","sourceRoot":"","sources":["../../src/library/components/GalleryDisplay.tsx"],"names":[],"mappings":"AAYA,wBAAgB,cAAc,4CA4C7B"}

package/dist/components/GalleryDisplay.js

@@ -1,42 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState, useRef } from "react";
-import { Box } from "@mui/material";
-import { useEventChannelState } from "../hooks/useEventChannelState";
-import { useModalState } from "../hooks/useModalState";
-import { GalleryViewer } from "./GalleryViewer";
-import useSize from "@react-hook/size";
-import { useAnimationSpeedMultiplier } from "../hooks/useTimeController";
-import { useGameTheme } from "../hooks/useGameTheme";
-import { GameModalBackdrop } from "./GameModalBackdrop";
-const DELAY = 300;
-export function GalleryDisplay() {
-    const theme = useGameTheme();
-    const animationSpeedMultiplier = useAnimationSpeedMultiplier();
-    const ref = useRef(null);
-    const [width, height] = useSize(ref);
-    const modalState = useModalState();
-    const [items, setItems] = useState(undefined);
-    const [source, setSource] = useEventChannelState(modalState.gallerySource);
-    const hasItems = items && items?.length > 0;
-    useEffect(() => {
-        if (source) {
-            setItems(source.items);
-            const unSub = source.registerUpdateHandler(() => {
-                setItems(source.items);
-            });
-            return () => {
-                source.close();
-                unSub();
-            };
-        }
-        else {
-            setItems(undefined);
-        }
-    }, [source, setItems]);
-    return (
-    // This has to be outside of the modal backdrop so we can get the size correctly
-    _jsx(Box, { ref: ref, sx: { position: "absolute", top: 0, left: 0, right: 0, bottom: 0 }, children: _jsx(GameModalBackdrop, { visible: !!hasItems, children: _jsx(GalleryViewer, { onClose: () => {
-                    setSource(undefined);
-                }, items: items ?? [], tweenDuration: DELAY * animationSpeedMultiplier * 0.8, galleryItemWidth: theme.galleryItemWidth, galleryItemHeight: theme.galleryItemHeight, itemSpacing: theme.galleryItemSpacing, w: width, h: height }) }) }));
-}
-//# sourceMappingURL=GalleryDisplay.js.map

package/dist/components/GalleryDisplay.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GalleryDisplay.js","sourceRoot":"","sources":["../../src/library/components/GalleryDisplay.tsx"],"names":[],"mappings":";AAAA,OAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAe,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,OAAO,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,KAAK,GAAG,GAAG,CAAC;AAElB,MAAM,UAAU,cAAc;IAC5B,MAAM,KAAK,GAAG,YAAY,EAAE,CAAC;IAC7B,MAAM,wBAAwB,GAAG,2BAA2B,EAAE,CAAC;IAC/D,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IACzB,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACrC,MAAM,UAAU,GAAG,aAAa,EAAE,CAAC;IACnC,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAA4B,SAAS,CAAC,CAAC;IACzE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,oBAAoB,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IAC3E,MAAM,QAAQ,GAAG,KAAK,IAAI,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAE5C,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,MAAM,EAAE,CAAC;YACX,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACvB,MAAM,KAAK,GAAG,MAAM,CAAC,qBAAqB,CAAC,GAAG,EAAE;gBAC9C,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC;YACH,OAAO,GAAG,EAAE;gBACV,MAAM,CAAC,KAAK,EAAE,CAAC;gBACf,KAAK,EAAE,CAAC;YACV,CAAC,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,QAAQ,CAAC,SAAS,CAAC,CAAC;QACtB,CAAC;IACH,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAEvB,OAAO;IACL,gFAAgF;IAChF,KAAC,GAAG,IAAC,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,YAC/E,KAAC,iBAAiB,IAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,YACpC,KAAC,aAAa,IACZ,OAAO,EAAE,GAAG,EAAE;oBACZ,SAAS,CAAC,SAAS,CAAC,CAAC;gBACvB,CAAC,EACD,KAAK,EAAE,KAAK,IAAI,EAAE,EAClB,aAAa,EAAE,KAAK,GAAG,wBAAwB,GAAG,GAAG,EACrD,gBAAgB,EAAE,KAAK,CAAC,gBAAgB,EACxC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,EAC1C,WAAW,EAAE,KAAK,CAAC,kBAAkB,EACrC,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,MAAM,GACT,GACgB,GAChB,CACP,CAAC;AACJ,CAAC"}

package/dist/utilities/OutlineCanvas.d.ts

@@ -1,12 +0,0 @@
-import { ParameterizedCanvas } from "./ParameterizedCanvas";
-export declare class OutlineCanvas extends ParameterizedCanvas {
-    radius: number;
-    lineWidth: number;
-    innerLineWidth: number;
-    outerColor: string;
-    innerColor: string;
-    width: number;
-    height: number;
-    render(): import("react/jsx-runtime").JSX.Element;
-}
-//# sourceMappingURL=OutlineCanvas.d.ts.map

package/dist/utilities/OutlineCanvas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OutlineCanvas.d.ts","sourceRoot":"","sources":["../../src/library/utilities/OutlineCanvas.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAa,aAAc,SAAQ,mBAAmB;IACpD,MAAM,SAAK;IACX,SAAS,SAAK;IACd,cAAc,SAAK;IACnB,UAAU,SAAU;IACpB,UAAU,SAAU;IACpB,KAAK,SAAO;IACZ,MAAM,SAAO;IACb,MAAM;CAgCP"}

package/dist/utilities/OutlineCanvas.js

@@ -1,31 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Raw } from "./CanvasStack/ReactCanvas";
-import { ParameterizedCanvas } from "./ParameterizedCanvas";
-export class OutlineCanvas extends ParameterizedCanvas {
-    constructor() {
-        super(...arguments);
-        this.radius = 6;
-        this.lineWidth = 6;
-        this.innerLineWidth = 2;
-        this.outerColor = "#f00";
-        this.innerColor = "#ff0";
-        this.width = 100;
-        this.height = 100;
-    }
-    render() {
-        return (_jsx(Raw, { cb: (ctx, x, y, w, h) => {
-                ctx.imageSmoothingEnabled = false;
-                ctx.strokeStyle = this.outerColor;
-                ctx.lineWidth = this.lineWidth;
-                ctx.beginPath();
-                ctx.roundRect(x + this.lineWidth / 2, y + this.lineWidth / 2, w - this.lineWidth, h - this.lineWidth, this.radius);
-                ctx.stroke();
-                ctx.strokeStyle = this.innerColor;
-                ctx.lineWidth = this.innerLineWidth;
-                ctx.beginPath();
-                ctx.roundRect(x + this.lineWidth / 2, y + this.lineWidth / 2, w - this.lineWidth, h - this.lineWidth, this.radius);
-                ctx.stroke();
-            } }));
-    }
-}
-//# sourceMappingURL=OutlineCanvas.js.map

package/dist/utilities/OutlineCanvas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OutlineCanvas.js","sourceRoot":"","sources":["../../src/library/utilities/OutlineCanvas.tsx"],"names":[],"mappings":";AACA,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,OAAO,aAAc,SAAQ,mBAAmB;IAAtD;;QACE,WAAM,GAAG,CAAC,CAAC;QACX,cAAS,GAAG,CAAC,CAAC;QACd,mBAAc,GAAG,CAAC,CAAC;QACnB,eAAU,GAAG,MAAM,CAAC;QACpB,eAAU,GAAG,MAAM,CAAC;QACpB,UAAK,GAAG,GAAG,CAAC;QACZ,WAAM,GAAG,GAAG,CAAC;KAiCd;IAhCC,MAAM;QACJ,OAAO,CACL,KAAC,GAAG,IACF,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;gBACtB,GAAG,CAAC,qBAAqB,GAAG,KAAK,CAAC;gBAClC,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC;gBAClC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;gBAC/B,GAAG,CAAC,SAAS,EAAE,CAAC;gBAChB,GAAG,CAAC,SAAS,CACX,CAAC,GAAG,IAAI,CAAC,SAAS,GAAG,CAAC,EACtB,CAAC,GAAG,IAAI,CAAC,SAAS,GAAG,CAAC,EACtB,CAAC,GAAG,IAAI,CAAC,SAAS,EAClB,CAAC,GAAG,IAAI,CAAC,SAAS,EAClB,IAAI,CAAC,MAAM,CACZ,CAAC;gBACF,GAAG,CAAC,MAAM,EAAE,CAAC;gBAEb,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC;gBAClC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC;gBACpC,GAAG,CAAC,SAAS,EAAE,CAAC;gBAChB,GAAG,CAAC,SAAS,CACX,CAAC,GAAG,IAAI,CAAC,SAAS,GAAG,CAAC,EACtB,CAAC,GAAG,IAAI,CAAC,SAAS,GAAG,CAAC,EACtB,CAAC,GAAG,IAAI,CAAC,SAAS,EAClB,CAAC,GAAG,IAAI,CAAC,SAAS,EAClB,IAAI,CAAC,MAAM,CACZ,CAAC;gBACF,GAAG,CAAC,MAAM,EAAE,CAAC;YACf,CAAC,GACD,CACH,CAAC;IACJ,CAAC;CACF"}

package/dist/utilities/OutlineGeometry.d.ts

@@ -1,3 +0,0 @@
-import { BufferGeometry, ExtrudeGeometry, Shape } from "three";
-export declare function outlineGeometry(shape: Shape, height: number): BufferGeometry | ExtrudeGeometry;
-//# sourceMappingURL=OutlineGeometry.d.ts.map

package/dist/utilities/OutlineGeometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OutlineGeometry.d.ts","sourceRoot":"","sources":["../../src/library/utilities/OutlineGeometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAQ,KAAK,EAAE,MAAM,OAAO,CAAC;AAGrE,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,eAAe,CAiE9F"}

package/dist/utilities/OutlineGeometry.js

@@ -1,57 +0,0 @@
-import { ExtrudeGeometry, Mesh } from "three";
-import { CSG } from "three-csg-ts";
-export function outlineGeometry(shape, height) {
-    // const extrudeSettings = {
-    //   depth: height, // Extrude by 2 units
-    //   bevelEnabled: false, // Disable bevel for simplicity
-    // };
-    const g = new ExtrudeGeometry(shape, { depth: height * 20, bevelEnabled: false });
-    g.scale(0.95, 0.95, 0.95);
-    const g2 = new ExtrudeGeometry(shape, { depth: height, bevelEnabled: false });
-    g2.scale(1.05, 1.05, 1.45);
-    const original = new Mesh(g);
-    const scaled = new Mesh(g2);
-    original.updateMatrix();
-    scaled.updateMatrix();
-    // scaled.scale(1.05, 1.05, 1.05);
-    const subRes = CSG.subtract(scaled, original);
-    subRes.geometry.translate(0, 0, -(subRes.geometry.boundingBox?.max.z ?? 0) / 2);
-    // return scaled.geometry;
-    return subRes.geometry;
-    // const stroke = extrude({ thickness: 0.05, cap: "square", join: "none", miterLimit: 10 });
-    // const m = stroke.build(vectors.map((v) => [v.x, v.y]));
-    // const vertexCount = m.positions.length;
-    // const topVertices = m.positions.map((p) => [p[0], p[1], height / 2]).flat();
-    // const bottomVertices = m.positions.map((p) => [p[0], p[1], -height / 2]).flat();
-    // const vertices = new Float32Array(topVertices.concat(bottomVertices));
-    // const top: number[][] = [];
-    // const bottom: number[][] = [];
-    // const sides: number[][] = [];
-    // const hasAddedTriangles = new Set<string>();
-    // const addSide = (a: number, b: number) => {
-    //   const key = `${a}_${b}`;
-    //   if (!hasAddedTriangles.has(key)) {
-    //     hasAddedTriangles.add(key);
-    //     sides.push([a + vertexCount, b, a]);
-    //     sides.push([a + vertexCount, b + vertexCount, b]);
-    //   }
-    // };
-    // m.cells.forEach((triangle) => {
-    //   const [a, b, c] = triangle;
-    //   top.push([c, b, a]);
-    //   bottom.push([a + vertexCount, b + vertexCount, c + vertexCount]); // add bottom triangle
-    //   addSide(a, b);
-    //   addSide(c, a);
-    //   addSide(c, b);
-    // });
-    // // const cells = new Uint16Array(triangles.flat());
-    // const geometry = new BufferGeometry();
-    // geometry.setAttribute("position", new BufferAttribute(vertices, 3));
-    // geometry.setIndex(new BufferAttribute(new Uint16Array([...top.flat(), ...bottom.flat(), ...sides.flat()]), 1));
-    // geometry.addGroup(0, top.length * 3, 0);
-    // geometry.addGroup(top.length * 3, bottom.length * 3, 1);
-    // geometry.addGroup(top.length * 6, 3 * sides.length, 2);
-    // geometry.computeVertexNormals();
-    // // geometry.computeTangents();
-}
-//# sourceMappingURL=OutlineGeometry.js.map

package/dist/utilities/OutlineGeometry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OutlineGeometry.js","sourceRoot":"","sources":["../../src/library/utilities/OutlineGeometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,eAAe,EAAE,IAAI,EAAS,MAAM,OAAO,CAAC;AACrE,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAEnC,MAAM,UAAU,eAAe,CAAC,KAAY,EAAE,MAAc;IAC1D,4BAA4B;IAC5B,yCAAyC;IACzC,yDAAyD;IACzD,KAAK;IAEL,MAAM,CAAC,GAAG,IAAI,eAAe,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;IAClF,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IAC1B,MAAM,EAAE,GAAG,IAAI,eAAe,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9E,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IAC3B,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;IAC7B,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC;IAE5B,QAAQ,CAAC,YAAY,EAAE,CAAC;IACxB,MAAM,CAAC,YAAY,EAAE,CAAC;IACtB,kCAAkC;IAElC,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAE9C,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAChF,0BAA0B;IAC1B,OAAO,MAAM,CAAC,QAAQ,CAAC;IAEvB,4FAA4F;IAE5F,0DAA0D;IAE1D,0CAA0C;IAC1C,+EAA+E;IAC/E,mFAAmF;IAEnF,yEAAyE;IACzE,8BAA8B;IAC9B,iCAAiC;IACjC,gCAAgC;IAChC,+CAA+C;IAE/C,8CAA8C;IAC9C,6BAA6B;IAC7B,uCAAuC;IACvC,kCAAkC;IAClC,2CAA2C;IAC3C,yDAAyD;IACzD,MAAM;IACN,KAAK;IAEL,kCAAkC;IAClC,gCAAgC;IAChC,yBAAyB;IACzB,6FAA6F;IAC7F,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;IACnB,MAAM;IAEN,sDAAsD;IACtD,yCAAyC;IACzC,uEAAuE;IACvE,kHAAkH;IAElH,2CAA2C;IAC3C,2DAA2D;IAC3D,0DAA0D;IAC1D,mCAAmC;IACnC,iCAAiC;AACnC,CAAC"}

package/src/library/utilities/OutlineCanvas.tsx

@@ -1,45 +0,0 @@
-import React from "react";
-import { Raw } from "./CanvasStack/ReactCanvas";
-import { ParameterizedCanvas } from "./ParameterizedCanvas";
-
-export class OutlineCanvas extends ParameterizedCanvas {
-  radius = 6;
-  lineWidth = 6;
-  innerLineWidth = 2;
-  outerColor = "#f00";
-  innerColor = "#ff0";
-  width = 100;
-  height = 100;
-  render() {
-    return (
-      <Raw
-        cb={(ctx, x, y, w, h) => {
-          ctx.imageSmoothingEnabled = false;
-          ctx.strokeStyle = this.outerColor;
-          ctx.lineWidth = this.lineWidth;
-          ctx.beginPath();
-          ctx.roundRect(
-            x + this.lineWidth / 2,
-            y + this.lineWidth / 2,
-            w - this.lineWidth,
-            h - this.lineWidth,
-            this.radius,
-          );
-          ctx.stroke();
-
-          ctx.strokeStyle = this.innerColor;
-          ctx.lineWidth = this.innerLineWidth;
-          ctx.beginPath();
-          ctx.roundRect(
-            x + this.lineWidth / 2,
-            y + this.lineWidth / 2,
-            w - this.lineWidth,
-            h - this.lineWidth,
-            this.radius,
-          );
-          ctx.stroke();
-        }}
-      />
-    );
-  }
-}