@spiffcommerce/preview 3.6.2-rc.3 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Misc/decorators.esm.js

@@ -0,0 +1,332 @@
+import { Tags as p } from "./tags.esm.js";
+import { Matrix as C, Quaternion as b, Vector3 as I, Vector2 as h } from "../Maths/math.vector.esm.js";
+import { _WarnImport as y } from "./devTools.esm.js";
+import { Color4 as T, Color3 as w } from "../Maths/math.color.esm.js";
+const g = {}, d = {}, P = function(s, t, e, o = {}) {
+  const a = s();
+  p && p.HasTags(t) && p.AddTagsTo(a, p.GetTags(t, !0));
+  const c = k(a), r = {};
+  for (const i in c) {
+    const n = c[i], l = t[i], u = n.type;
+    if (l != null && (i !== "uniqueId" || f.AllowLoadingUniqueId))
+      switch (u) {
+        case 0:
+        case 6:
+        case 11:
+          a[i] = l;
+          break;
+        case 1:
+          o.cloneTexturesOnlyOnce && r[l.uniqueId] ? a[i] = r[l.uniqueId] : (a[i] = e || l.isRenderTarget ? l : l.clone(), r[l.uniqueId] = a[i]);
+          break;
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 7:
+        case 10:
+        case 12:
+          a[i] = e ? l : l.clone();
+          break;
+      }
+  }
+  return a;
+};
+function q(s) {
+  const t = s.getClassName();
+  return g[t] || (g[t] = {}), g[t];
+}
+function k(s) {
+  const t = s.getClassName();
+  if (d[t])
+    return d[t];
+  d[t] = {};
+  const e = d[t];
+  let o = s, a = t;
+  for (; a; ) {
+    const c = g[a];
+    for (const n in c)
+      e[n] = c[n];
+    let r, i = !1;
+    do {
+      if (r = Object.getPrototypeOf(o), !r.getClassName) {
+        i = !0;
+        break;
+      }
+      if (r.getClassName() !== a)
+        break;
+      o = r;
+    } while (r);
+    if (i)
+      break;
+    a = r.getClassName(), o = r;
+  }
+  return e;
+}
+function m(s, t) {
+  return (e, o) => {
+    const a = q(e);
+    a[o] || (a[o] = { type: s, sourceName: t });
+  };
+}
+function x(s, t = null) {
+  return (e, o) => {
+    const a = t || "_" + o;
+    Object.defineProperty(e, o, {
+      get: function() {
+        return this[a];
+      },
+      set: function(c) {
+        typeof this.equals == "function" && this.equals(c) || this[a] !== c && (this[a] = c, e[s].apply(this));
+      },
+      enumerable: !0,
+      configurable: !0
+    });
+  };
+}
+function M(s, t = null) {
+  return x(s, t);
+}
+function S(s) {
+  return m(0, s);
+}
+function L(s) {
+  return m(1, s);
+}
+function D(s) {
+  return m(2, s);
+}
+function V(s) {
+  return m(3, s);
+}
+function R(s) {
+  return m(4, s);
+}
+function U(s) {
+  return m(5, s);
+}
+function B(s) {
+  return m(6, s);
+}
+function G(s) {
+  return m(7, s);
+}
+function Q(s) {
+  return m(8, s);
+}
+function E(s) {
+  return m(9, s);
+}
+function W(s) {
+  return m(10, s);
+}
+function z(s) {
+  return m(12, s);
+}
+function J(s) {
+  return m(11, s);
+}
+class f {
+  /**
+   * Appends the serialized animations from the source animations
+   * @param source Source containing the animations
+   * @param destination Target to store the animations
+   */
+  static AppendSerializedAnimations(t, e) {
+    if (t.animations) {
+      e.animations = [];
+      for (let o = 0; o < t.animations.length; o++) {
+        const a = t.animations[o];
+        e.animations.push(a.serialize());
+      }
+    }
+  }
+  /**
+   * Static function used to serialized a specific entity
+   * @param entity defines the entity to serialize
+   * @param serializationObject defines the optional target object where serialization data will be stored
+   * @returns a JSON compatible object representing the serialization of the entity
+   */
+  static Serialize(t, e) {
+    e || (e = {}), p && (e.tags = p.GetTags(t));
+    const o = k(t);
+    for (const a in o) {
+      const c = o[a], r = c.sourceName || a, i = c.type, n = t[a];
+      if (n != null && (a !== "uniqueId" || f.AllowLoadingUniqueId))
+        switch (i) {
+          case 0:
+            e[r] = n;
+            break;
+          case 1:
+            e[r] = n.serialize();
+            break;
+          case 2:
+            e[r] = n.asArray();
+            break;
+          case 3:
+            e[r] = n.serialize();
+            break;
+          case 4:
+            e[r] = n.asArray();
+            break;
+          case 5:
+            e[r] = n.asArray();
+            break;
+          case 6:
+            e[r] = n.id;
+            break;
+          case 7:
+            e[r] = n.serialize();
+            break;
+          case 8:
+            e[r] = n.asArray();
+            break;
+          case 9:
+            e[r] = n.serialize();
+            break;
+          case 10:
+            e[r] = n.asArray();
+            break;
+          case 11:
+            e[r] = n.id;
+            break;
+          case 12:
+            e[r] = n.asArray();
+            break;
+        }
+    }
+    return e;
+  }
+  /**
+   * Given a source json and a destination object in a scene, this function will parse the source and will try to apply its content to the destination object
+   * @param source the source json data
+   * @param destination the destination object
+   * @param scene the scene where the object is
+   * @param rootUrl root url to use to load assets
+   */
+  static ParseProperties(t, e, o, a) {
+    a || (a = "");
+    const c = k(e);
+    for (const r in c) {
+      const i = c[r], n = t[i.sourceName || r], l = i.type;
+      if (n != null && (r !== "uniqueId" || f.AllowLoadingUniqueId)) {
+        const u = e;
+        switch (l) {
+          case 0:
+            u[r] = n;
+            break;
+          case 1:
+            o && (u[r] = f._TextureParser(n, o, a));
+            break;
+          case 2:
+            u[r] = w.FromArray(n);
+            break;
+          case 3:
+            u[r] = f._FresnelParametersParser(n);
+            break;
+          case 4:
+            u[r] = h.FromArray(n);
+            break;
+          case 5:
+            u[r] = I.FromArray(n);
+            break;
+          case 6:
+            o && (u[r] = o.getLastMeshById(n));
+            break;
+          case 7:
+            u[r] = f._ColorCurvesParser(n);
+            break;
+          case 8:
+            u[r] = T.FromArray(n);
+            break;
+          case 9:
+            u[r] = f._ImageProcessingConfigurationParser(n);
+            break;
+          case 10:
+            u[r] = b.FromArray(n);
+            break;
+          case 11:
+            o && (u[r] = o.getCameraById(n));
+            break;
+          case 12:
+            u[r] = C.FromArray(n);
+            break;
+        }
+      }
+    }
+  }
+  /**
+   * Creates a new entity from a serialization data object
+   * @param creationFunction defines a function used to instanciated the new entity
+   * @param source defines the source serialization data
+   * @param scene defines the hosting scene
+   * @param rootUrl defines the root url for resources
+   * @returns a new entity
+   */
+  static Parse(t, e, o, a = null) {
+    const c = t();
+    return p && p.AddTagsTo(c, e.tags), f.ParseProperties(e, c, o, a), c;
+  }
+  /**
+   * Clones an object
+   * @param creationFunction defines the function used to instanciate the new object
+   * @param source defines the source object
+   * @returns the cloned object
+   */
+  static Clone(t, e, o = {}) {
+    return P(t, e, !1, o);
+  }
+  /**
+   * Instanciates a new object based on a source one (some data will be shared between both object)
+   * @param creationFunction defines the function used to instanciate the new object
+   * @param source defines the source object
+   * @returns the new object
+   */
+  static Instanciate(t, e) {
+    return P(t, e, !0);
+  }
+}
+f.AllowLoadingUniqueId = !1;
+f._ImageProcessingConfigurationParser = (s) => {
+  throw y("ImageProcessingConfiguration");
+};
+f._FresnelParametersParser = (s) => {
+  throw y("FresnelParameters");
+};
+f._ColorCurvesParser = (s) => {
+  throw y("ColorCurves");
+};
+f._TextureParser = (s, t, e) => {
+  throw y("Texture");
+};
+function A(s, t, e, o) {
+  const a = e.value;
+  e.value = (...c) => {
+    let r = a;
+    if (typeof _native < "u" && _native[t]) {
+      const i = _native[t];
+      o ? r = (...n) => o(...n) ? i(...n) : a(...n) : r = i;
+    }
+    return s[t] = r, r(...c);
+  };
+}
+A.filter = function(s) {
+  return (t, e, o) => A(t, e, o, s);
+};
+export {
+  f as SerializationHelper,
+  M as expandToProperty,
+  A as nativeOverride,
+  S as serialize,
+  J as serializeAsCameraReference,
+  D as serializeAsColor3,
+  Q as serializeAsColor4,
+  G as serializeAsColorCurves,
+  V as serializeAsFresnelParameters,
+  E as serializeAsImageProcessingConfiguration,
+  z as serializeAsMatrix,
+  B as serializeAsMeshReference,
+  W as serializeAsQuaternion,
+  L as serializeAsTexture,
+  R as serializeAsVector2,
+  U as serializeAsVector3
+};

package/dist/node_modules/@babylonjs/core/Misc/deepCopier.esm.js

@@ -0,0 +1,52 @@
+import { Logger as u } from "./logger.esm.js";
+const o = (e, r) => !e || e.getClassName && e.getClassName() === "Mesh" ? null : e.getClassName && (e.getClassName() === "SubMesh" || e.getClassName() === "PhysicsBody") ? e.clone(r) : e.clone ? e.clone() : Array.isArray(e) ? e.slice() : null;
+function y(e) {
+  const r = [];
+  do
+    Object.getOwnPropertyNames(e).forEach(function(l) {
+      r.indexOf(l) === -1 && r.push(l);
+    });
+  while (e = Object.getPrototypeOf(e));
+  return r;
+}
+class h {
+  /**
+   * Tries to copy an object by duplicating every property
+   * @param source defines the source object
+   * @param destination defines the target object
+   * @param doNotCopyList defines a list of properties to avoid
+   * @param mustCopyList defines a list of properties to copy (even if they start with _)
+   */
+  static DeepCopy(r, l, i, s) {
+    const p = y(r);
+    for (const n of p) {
+      if (n[0] === "_" && (!s || s.indexOf(n) === -1) || n.endsWith("Observable") || i && i.indexOf(n) !== -1)
+        continue;
+      const f = r[n], c = typeof f;
+      if (c !== "function")
+        try {
+          if (c === "object")
+            if (f instanceof Uint8Array)
+              l[n] = Uint8Array.from(f);
+            else if (f instanceof Array) {
+              if (l[n] = [], f.length > 0)
+                if (typeof f[0] == "object")
+                  for (let t = 0; t < f.length; t++) {
+                    const a = o(f[t], l);
+                    l[n].indexOf(a) === -1 && l[n].push(a);
+                  }
+                else
+                  l[n] = f.slice(0);
+            } else
+              l[n] = o(f, l);
+          else
+            l[n] = f;
+        } catch (t) {
+          u.Warn(t.message);
+        }
+    }
+  }
+}
+export {
+  h as DeepCopier
+};

package/dist/node_modules/@babylonjs/core/Misc/deferred.esm.js

@@ -0,0 +1,25 @@
+class s {
+  /**
+   * The resolve method of the promise associated with this deferred object.
+   */
+  get resolve() {
+    return this._resolve;
+  }
+  /**
+   * The reject method of the promise associated with this deferred object.
+   */
+  get reject() {
+    return this._reject;
+  }
+  /**
+   * Constructor for this deferred object.
+   */
+  constructor() {
+    this.promise = new Promise((e, r) => {
+      this._resolve = e, this._reject = r;
+    });
+  }
+}
+export {
+  s as Deferred
+};

package/dist/node_modules/@babylonjs/core/Misc/devTools.esm.js

@@ -0,0 +1,6 @@
+function r(e) {
+  return `${e} needs to be imported before as it contains a side-effect required by your code.`;
+}
+export {
+  r as _WarnImport
+};

package/dist/node_modules/@babylonjs/core/Misc/domManagement.esm.js

@@ -0,0 +1,21 @@
+function i() {
+  return typeof window < "u";
+}
+function o() {
+  return typeof navigator < "u";
+}
+function u() {
+  return typeof document < "u";
+}
+function r(n) {
+  let t = "", e = n.firstChild;
+  for (; e; )
+    e.nodeType === 3 && (t += e.textContent), e = e.nextSibling;
+  return t;
+}
+export {
+  r as GetDOMTextContent,
+  u as IsDocumentAvailable,
+  o as IsNavigatorAvailable,
+  i as IsWindowObjectExist
+};

package/dist/node_modules/@babylonjs/core/Misc/dumpTools.esm.js

@@ -0,0 +1,117 @@
+import { ThinEngine as D } from "../Engines/thinEngine.esm.js";
+import { EffectRenderer as v, EffectWrapper as y } from "../Materials/effectRenderer.esm.js";
+import { Tools as c } from "./tools.esm.js";
+import { passPixelShader as w } from "../Shaders/pass.fragment.esm.js";
+import { Scalar as A } from "../Maths/math.scalar.esm.js";
+class e {
+  static _CreateDumpRenderer() {
+    if (!e._DumpToolsEngine) {
+      let n = new OffscreenCanvas(100, 100), r = null;
+      const a = {
+        preserveDrawingBuffer: !0,
+        depth: !1,
+        stencil: !1,
+        alpha: !0,
+        premultipliedAlpha: !1,
+        antialias: !1,
+        failIfMajorPerformanceCaveat: !1
+      };
+      try {
+        r = new D(n, !1, a);
+      } catch {
+        n = document.createElement("canvas"), r = new D(n, !1, a);
+      }
+      r.getCaps().parallelShaderCompile = void 0;
+      const s = new v(r), i = new y({
+        engine: r,
+        name: w.name,
+        fragmentShader: w.shader,
+        samplerNames: ["textureSampler"]
+      });
+      e._DumpToolsEngine = {
+        canvas: n,
+        engine: r,
+        renderer: s,
+        wrapper: i
+      };
+    }
+    return e._DumpToolsEngine;
+  }
+  /**
+   * Dumps the current bound framebuffer
+   * @param width defines the rendering width
+   * @param height defines the rendering height
+   * @param engine defines the hosting engine
+   * @param successCallback defines the callback triggered once the data are available
+   * @param mimeType defines the mime type of the result
+   * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   * @returns a void promise
+   */
+  static async DumpFramebuffer(n, r, a, s, i = "image/png", f, o) {
+    const m = await a.readPixels(0, 0, n, r), p = new Uint8Array(m.buffer);
+    e.DumpData(n, r, p, s, i, f, !0, void 0, o);
+  }
+  /**
+   * Dumps an array buffer
+   * @param width defines the rendering width
+   * @param height defines the rendering height
+   * @param data the data array
+   * @param mimeType defines the mime type of the result
+   * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+   * @param invertY true to invert the picture in the Y dimension
+   * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   * @returns a promise that resolve to the final data
+   */
+  static DumpDataAsync(n, r, a, s = "image/png", i, f = !1, o = !1, m) {
+    return new Promise((p) => {
+      e.DumpData(n, r, a, (t) => p(t), s, i, f, o, m);
+    });
+  }
+  /**
+   * Dumps an array buffer
+   * @param width defines the rendering width
+   * @param height defines the rendering height
+   * @param data the data array
+   * @param successCallback defines the callback triggered once the data are available
+   * @param mimeType defines the mime type of the result
+   * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+   * @param invertY true to invert the picture in the Y dimension
+   * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   */
+  static DumpData(n, r, a, s, i = "image/png", f, o = !1, m = !1, p) {
+    const t = e._CreateDumpRenderer();
+    if (t.engine.setSize(n, r, !0), a instanceof Float32Array) {
+      const u = new Uint8Array(a.length);
+      let l = a.length;
+      for (; l--; ) {
+        const d = a[l];
+        u[l] = Math.round(A.Clamp(d) * 255);
+      }
+      a = u;
+    }
+    const g = t.engine.createRawTexture(a, n, r, 5, !1, !o, 1);
+    t.renderer.setViewport(), t.renderer.applyEffectWrapper(t.wrapper), t.wrapper.effect._bindTexture("textureSampler", g), t.renderer.draw(), m ? c.ToBlob(t.canvas, (u) => {
+      const l = new FileReader();
+      l.onload = (d) => {
+        const E = d.target.result;
+        s && s(E);
+      }, l.readAsArrayBuffer(u);
+    }, i, p) : c.EncodeScreenshotCanvasData(t.canvas, s, i, f, p), g.dispose();
+  }
+  /**
+   * Dispose the dump tools associated resources
+   */
+  static Dispose() {
+    e._DumpToolsEngine && (e._DumpToolsEngine.wrapper.dispose(), e._DumpToolsEngine.renderer.dispose(), e._DumpToolsEngine.engine.dispose()), e._DumpToolsEngine = null;
+  }
+}
+const S = () => {
+  c.DumpData = e.DumpData, c.DumpDataAsync = e.DumpDataAsync, c.DumpFramebuffer = e.DumpFramebuffer;
+};
+S();
+export {
+  e as DumpTools
+};