promogame-player 0.0.2

package/dist/components/PromogameGame/unity-game.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface UnityGameProps extends React.RefAttributes<HTMLCanvasElement> {
+    gameLink?: string;
+    loadingComponent?: React.ComponentType<{
+        progress: number;
+    }>;
+    className?: string;
+}
+export declare const UnityGame: React.ForwardRefExoticComponent<Omit<UnityGameProps, "ref"> & React.RefAttributes<HTMLCanvasElement>>;

package/dist/components/PromogameGame/unity-game.js

@@ -0,0 +1,657 @@
+import { jsxs as P, Fragment as oe, jsx as $ } from "react/jsx-runtime";
+import * as le from "react";
+import g, { useEffect as ce } from "react";
+import { cn as de } from "../../utils.js";
+var j = {}, L = {}, S = {}, B;
+function ve() {
+  if (B) return S;
+  B = 1, Object.defineProperty(S, "__esModule", { value: !0 }), S.useUnityCanvasId = void 0;
+  var l = g, c = 0, a = "react-unity-webgl-canvas", v = function(f) {
+    if (f.id !== void 0)
+      return f.id;
+    var m = (0, l.useMemo)(function() {
+      return [a, ++c].join("-");
+    }, []);
+    return m;
+  };
+  return S.useUnityCanvasId = v, S;
+}
+var w = {}, p = {}, F;
+function Y() {
+  if (F) return p;
+  F = 1, Object.defineProperty(p, "__esModule", { value: !0 }), p.UnityLoaderStatus = void 0;
+  var l;
+  return function(c) {
+    c.Idle = "Idle", c.Loading = "Loading", c.Loaded = "Loaded", c.Error = "Error";
+  }(l || (p.UnityLoaderStatus = l = {})), p;
+}
+var q = {}, G;
+function R() {
+  return G || (G = 1, Object.defineProperty(q, "__esModule", { value: !0 }), q.isBrowserEnvironment = void 0, q.isBrowserEnvironment = typeof window < "u" && typeof document < "u"), q;
+}
+var T;
+function fe() {
+  if (T) return w;
+  T = 1;
+  var l = w && w.__awaiter || function(U, u, n, e) {
+    function s(r) {
+      return r instanceof n ? r : new n(function(t) {
+        t(r);
+      });
+    }
+    return new (n || (n = Promise))(function(r, t) {
+      function d(i) {
+        try {
+          o(e.next(i));
+        } catch (y) {
+          t(y);
+        }
+      }
+      function b(i) {
+        try {
+          o(e.throw(i));
+        } catch (y) {
+          t(y);
+        }
+      }
+      function o(i) {
+        i.done ? r(i.value) : s(i.value).then(d, b);
+      }
+      o((e = e.apply(U, u || [])).next());
+    });
+  }, c = w && w.__generator || function(U, u) {
+    var n = { label: 0, sent: function() {
+      if (r[0] & 1) throw r[1];
+      return r[1];
+    }, trys: [], ops: [] }, e, s, r, t = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+    return t.next = d(0), t.throw = d(1), t.return = d(2), typeof Symbol == "function" && (t[Symbol.iterator] = function() {
+      return this;
+    }), t;
+    function d(o) {
+      return function(i) {
+        return b([o, i]);
+      };
+    }
+    function b(o) {
+      if (e) throw new TypeError("Generator is already executing.");
+      for (; t && (t = 0, o[0] && (n = 0)), n; ) try {
+        if (e = 1, s && (r = o[0] & 2 ? s.return : o[0] ? s.throw || ((r = s.return) && r.call(s), 0) : s.next) && !(r = r.call(s, o[1])).done) return r;
+        switch (s = 0, r && (o = [o[0] & 2, r.value]), o[0]) {
+          case 0:
+          case 1:
+            r = o;
+            break;
+          case 4:
+            return n.label++, { value: o[1], done: !1 };
+          case 5:
+            n.label++, s = o[1], o = [0];
+            continue;
+          case 7:
+            o = n.ops.pop(), n.trys.pop();
+            continue;
+          default:
+            if (r = n.trys, !(r = r.length > 0 && r[r.length - 1]) && (o[0] === 6 || o[0] === 2)) {
+              n = 0;
+              continue;
+            }
+            if (o[0] === 3 && (!r || o[1] > r[0] && o[1] < r[3])) {
+              n.label = o[1];
+              break;
+            }
+            if (o[0] === 6 && n.label < r[1]) {
+              n.label = r[1], r = o;
+              break;
+            }
+            if (r && n.label < r[2]) {
+              n.label = r[2], n.ops.push(o);
+              break;
+            }
+            r[2] && n.ops.pop(), n.trys.pop();
+            continue;
+        }
+        o = u.call(U, n);
+      } catch (i) {
+        o = [6, i], s = 0;
+      } finally {
+        e = r = 0;
+      }
+      if (o[0] & 5) throw o[1];
+      return { value: o[0] ? o[1] : void 0, done: !0 };
+    }
+  };
+  Object.defineProperty(w, "__esModule", { value: !0 }), w.useUnityInstance = void 0;
+  var a = g, v = Y(), f = R(), m = function(U, u, n, e) {
+    (0, a.useEffect)(function() {
+      (function() {
+        return l(void 0, void 0, void 0, function() {
+          var s, r;
+          return c(this, function(t) {
+            switch (t.label) {
+              case 0:
+                if (f.isBrowserEnvironment === !1)
+                  return [
+                    2
+                    /*return*/
+                  ];
+                if (U !== v.UnityLoaderStatus.Loaded || u === null)
+                  return e.setUnityInstance(null), e.setInitialisationError(null), [
+                    2
+                    /*return*/
+                  ];
+                t.label = 1;
+              case 1:
+                return t.trys.push([1, 3, , 4]), [4, window.createUnityInstance(u, n, e.setLoadingProgression)];
+              case 2:
+                return s = t.sent(), e.setUnityInstance(s), e.setInitialisationError(null), [3, 4];
+              case 3:
+                return r = t.sent(), e.setUnityInstance(null), e.setInitialisationError(r), [3, 4];
+              case 4:
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      })();
+    }, [U, u, n, e]);
+  };
+  return w.useUnityInstance = m, w;
+}
+var M = {}, D;
+function ye() {
+  if (D) return M;
+  D = 1, Object.defineProperty(M, "__esModule", { value: !0 }), M.useUnityArguments = void 0;
+  var l = g, c = function(a) {
+    return (0, l.useMemo)(function() {
+      return {
+        // Assigns the data URL, framework URL, and code URL to the Unity
+        // arguments object.
+        dataUrl: a.unityProvider.unityConfig.dataUrl,
+        frameworkUrl: a.unityProvider.unityConfig.frameworkUrl,
+        codeUrl: a.unityProvider.unityConfig.codeUrl,
+        // Assigns the optional streaming assets URL, memory URL, symbols URL,
+        // and worker URL to the Unity arguments object.
+        streamingAssetsUrl: a.unityProvider.unityConfig.streamingAssetsUrl,
+        memoryUrl: a.unityProvider.unityConfig.memoryUrl,
+        symbolsUrl: a.unityProvider.unityConfig.symbolsUrl,
+        workerUrl: a.unityProvider.unityConfig.workerUrl,
+        // Assigns the optional company name, product name, and product version to
+        // the Unity arguments object.
+        companyName: a.unityProvider.unityConfig.companyName,
+        productName: a.unityProvider.unityConfig.productName,
+        productVersion: a.unityProvider.unityConfig.productVersion,
+        // Assigns the webgl context attributes to the Unity arguments object.
+        // If the webgl context attributes are not defined via the Unity Props,
+        // the default value of an empty object will be used.
+        webglContextAttributes: a.unityProvider.unityConfig.webglContextAttributes || {},
+        // Assigns the cache control value to the Unity arguments object. If the
+        // cache control value is not defined via the Unity Props, the default
+        // value of always `must-revalidate` will be used.
+        cacheControl: a.unityProvider.unityConfig.cacheControl || function() {
+          return "must-revalidate";
+        },
+        // Assigns the device pixel ratio to the Unity arguments object. If the
+        // device pixel ratio is not defined via the Unity Props, the default
+        // value of `1` will be used.
+        devicePixelRatio: a.devicePixelRatio || 1,
+        // Assigns the auto sync persistent data path value to the Unity arguments
+        // object. If the auto sync persistent data path value is not defined via
+        // the Unity Props, the default value of `undefined` will be used.
+        autoSyncPersistentDataPath: a.autoSyncPersistentDataPath,
+        // Assigns the match WebGL to canvas size value to the Unity arguments
+        // object. If the match WebGL to canvas size value is not defined via the
+        // Unity Props, the default value of `true` will be used.
+        matchWebGLToCanvasSize: typeof a.matchWebGLToCanvasSize == "boolean" ? a.matchWebGLToCanvasSize : !0,
+        // Assigns the disabled canvas events to the Unity arguments object. If
+        // the disabled canvas events are not defined via the Unity Props, the
+        // default value of `contextmenu` and `dragstart` will be used.
+        disabledCanvasEvents: a.disabledCanvasEvents || [
+          "contextmenu",
+          "dragstart"
+        ],
+        // Assigns the print hook to the Unity arguments object. This hook will
+        // be called whenever the Unity instance prints a message.
+        print: (
+          /**
+           * Intercept print events in order to catch messages and send them to
+           * the unity context instead.
+           * @param message The message to be printed.
+           */
+          function(v) {
+          }
+        ),
+        // Assigns the print error hook to the Unity arguments object. This hook
+        // will be called whenever the Unity instance prints an error.
+        printErr: (
+          /**
+           * Intercept print error events in order to catch messages and send them
+           * to the unity context instead.
+           * @param error The error to be printed.
+           */
+          function(v) {
+          }
+        )
+      };
+    }, []);
+  };
+  return M.useUnityArguments = c, M;
+}
+var x = {}, z;
+function Ue() {
+  if (z) return x;
+  z = 1, Object.defineProperty(x, "__esModule", { value: !0 }), x.useUnityLoader = void 0;
+  var l = g, c = R(), a = Y(), v = function(f) {
+    var m = (0, l.useState)(a.UnityLoaderStatus.Loading), U = m[0], u = m[1];
+    return (0, l.useEffect)(function() {
+      if (c.isBrowserEnvironment !== !1) {
+        if (f.loaderUrl === null) {
+          u(a.UnityLoaderStatus.Idle);
+          return;
+        }
+        var n = window.document.querySelector('script[src="'.concat(f.loaderUrl, '"]'));
+        n === null ? (n = window.document.createElement("script"), n.type = "text/javascript", n.src = f.loaderUrl, n.async = !0, n.setAttribute("data-status", "loading"), window.document.body.appendChild(n), n.addEventListener("load", function() {
+          return n == null ? void 0 : n.setAttribute("data-status", "loaded");
+        }), n.addEventListener("error", function() {
+          return n == null ? void 0 : n.setAttribute("data-status", "error");
+        })) : u(n.getAttribute("data-status") === "loaded" ? a.UnityLoaderStatus.Loaded : a.UnityLoaderStatus.Error);
+        var e = function(s) {
+          return u(s.type === "load" ? a.UnityLoaderStatus.Loaded : a.UnityLoaderStatus.Error);
+        };
+        return n.addEventListener("load", e), n.addEventListener("error", e), function() {
+          n !== null && (n.removeEventListener("load", e), n.removeEventListener("error", e), window.document.body.removeChild(n));
+        };
+      }
+    }, [f.loaderUrl]), U;
+  };
+  return x.useUnityLoader = v, x;
+}
+var V;
+function me() {
+  if (V) return L;
+  V = 1, Object.defineProperty(L, "__esModule", { value: !0 }), L.Unity = void 0;
+  var l = g, c = g, a = ve(), v = fe(), f = ye(), m = Ue(), U = (0, c.forwardRef)(
+    /**
+     * @param unityProps The Unity props provided the the Unity component.
+     * @param forwardedRef The forwarded ref to the Unity component.
+     * @returns The Unity canvas renderer.
+     */
+    function(u, n) {
+      var e = (0, c.useRef)(null), s = (0, a.useUnityCanvasId)(u), r = (0, f.useUnityArguments)(u), t = (0, m.useUnityLoader)(u.unityProvider.unityConfig);
+      return (0, v.useUnityInstance)(t, e.current, r, u.unityProvider), (0, l.useImperativeHandle)(n, function() {
+        return e.current;
+      }), (0, l.createElement)("canvas", {
+        ref: e,
+        id: s,
+        style: u.style,
+        className: u.className,
+        tabIndex: u.tabIndex
+      });
+    }
+  );
+  return L.Unity = U, L;
+}
+var h = {}, N = {}, W;
+function Z() {
+  if (W) return N;
+  W = 1, Object.defineProperty(N, "__esModule", { value: !0 }), N.errorMessages = void 0;
+  var l = {
+    /**
+     * A generic error message when the Unity Instance is not available.
+     */
+    genericNoUnityInstance: "No Unity Instance found.",
+    /**
+     * The error message for when no Unity Instance was found while trying to set
+     * the fullscreen mode.
+     */
+    requestFullscreenNoUnityInstance: "Unable to Set Fullscreen while Unity is not Instantiated.",
+    /**
+     * The error message for when no Unity Instance was found while trying to
+     * request the pointer lock.
+     */
+    requestPointerLockNoUnityInstanceOrCanvas: "Unable to Request Pointer Lock while Unity is not Instantiated or the Canvas is not found.",
+    /**
+     * The error message for when no Unity Instance was found while trying to send
+     * a message.
+     */
+    sendMessageNoUnityInstance: "Unable to Send Message while Unity is not Instantiated.",
+    /**
+     * The error message for when no Unity Instance was found while trying to quit
+     * the Unity Instance.
+     */
+    quitNoUnityInstance: "Unable to Quit Unity while Unity is not Instantiated.",
+    /**
+     * The error message for when no Unity Instance or Canvas was found while
+     * trying to take a screenshot.
+     */
+    screenshotNoUnityInstanceOrCanvas: "Unable to Take Screenshot while Unity is not Instantiated or Canvas is not available.",
+    /**
+     * The error message for when no event listener was found in the event
+     * system.
+     */
+    noEventListener: "Unable to find Event Listener in Event System for Event"
+  };
+  return N.errorMessages = l, N;
+}
+var E = {}, Q;
+function be() {
+  if (Q) return E;
+  Q = 1;
+  var l = E && E.__spreadArray || function(u, n, e) {
+    if (e || arguments.length === 2) for (var s = 0, r = n.length, t; s < r; s++)
+      (t || !(s in n)) && (t || (t = Array.prototype.slice.call(n, 0, s)), t[s] = n[s]);
+    return u.concat(t || Array.prototype.slice.call(n));
+  };
+  Object.defineProperty(E, "__esModule", { value: !0 }), E.useEventSystem = void 0;
+  var c = g, a = Z(), v = R(), f = [], m = function(u) {
+    for (var n = [], e = 1; e < arguments.length; e++)
+      n[e - 1] = arguments[e];
+    var s = void 0;
+    return f.forEach(function(r) {
+      s = r.apply(void 0, l([u], n, !1));
+    }), s;
+  };
+  v.isBrowserEnvironment === !0 && (window.dispatchReactUnityEvent = m);
+  var U = function() {
+    var u = (0, c.useRef)([]), n = (0, c.useCallback)(
+      /**
+       * @param eventName The name of the event to listen to.
+       * @param callback The callback to invoke when the event is fired.
+       */
+      function(r, t) {
+        u.current = l(l([], u.current, !0), [
+          { eventName: r, callback: t }
+        ], !1);
+      },
+      [u]
+    ), e = (0, c.useCallback)(
+      /**
+       * @param eventName The name of the event to remove.
+       * @param callback The callback to remove.
+       */
+      function(r, t) {
+        u.current = u.current.filter(function(d) {
+          return d.eventName !== r && d.callback !== t;
+        });
+      },
+      [u]
+    ), s = (0, c.useCallback)(
+      /**
+       * @param eventName The name of the event to dispatch.
+       * @param parameters The parameters to pass to the event listener.
+       */
+      function(r) {
+        for (var t = [], d = 1; d < arguments.length; d++)
+          t[d - 1] = arguments[d];
+        var b = u.current.find(function(o) {
+          return o.eventName === r;
+        });
+        if (typeof b > "u") {
+          console.warn(a.errorMessages.noEventListener, { eventName: r });
+          return;
+        }
+        return b.callback.apply(b, t);
+      },
+      [u]
+    );
+    return (0, c.useEffect)(function() {
+      return f.push(s), function() {
+        f.splice(f.indexOf(s), 1);
+      };
+    }, [s]), {
+      addEventListener: n,
+      removeEventListener: e
+    };
+  };
+  return E.useEventSystem = U, E;
+}
+var k = {}, H;
+function _e() {
+  if (H) return k;
+  H = 1, Object.defineProperty(k, "__esModule", { value: !0 }), k.useNullableState = void 0;
+  var l = g, c = function(a) {
+    return (0, l.useState)(a || null);
+  };
+  return k.useNullableState = c, k;
+}
+var J;
+function we() {
+  if (J) return h;
+  J = 1;
+  var l = h && h.__awaiter || function(u, n, e, s) {
+    function r(t) {
+      return t instanceof e ? t : new e(function(d) {
+        d(t);
+      });
+    }
+    return new (e || (e = Promise))(function(t, d) {
+      function b(y) {
+        try {
+          i(s.next(y));
+        } catch (C) {
+          d(C);
+        }
+      }
+      function o(y) {
+        try {
+          i(s.throw(y));
+        } catch (C) {
+          d(C);
+        }
+      }
+      function i(y) {
+        y.done ? t(y.value) : r(y.value).then(b, o);
+      }
+      i((s = s.apply(u, n || [])).next());
+    });
+  }, c = h && h.__generator || function(u, n) {
+    var e = { label: 0, sent: function() {
+      if (t[0] & 1) throw t[1];
+      return t[1];
+    }, trys: [], ops: [] }, s, r, t, d = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+    return d.next = b(0), d.throw = b(1), d.return = b(2), typeof Symbol == "function" && (d[Symbol.iterator] = function() {
+      return this;
+    }), d;
+    function b(i) {
+      return function(y) {
+        return o([i, y]);
+      };
+    }
+    function o(i) {
+      if (s) throw new TypeError("Generator is already executing.");
+      for (; d && (d = 0, i[0] && (e = 0)), e; ) try {
+        if (s = 1, r && (t = i[0] & 2 ? r.return : i[0] ? r.throw || ((t = r.return) && t.call(r), 0) : r.next) && !(t = t.call(r, i[1])).done) return t;
+        switch (r = 0, t && (i = [i[0] & 2, t.value]), i[0]) {
+          case 0:
+          case 1:
+            t = i;
+            break;
+          case 4:
+            return e.label++, { value: i[1], done: !1 };
+          case 5:
+            e.label++, r = i[1], i = [0];
+            continue;
+          case 7:
+            i = e.ops.pop(), e.trys.pop();
+            continue;
+          default:
+            if (t = e.trys, !(t = t.length > 0 && t[t.length - 1]) && (i[0] === 6 || i[0] === 2)) {
+              e = 0;
+              continue;
+            }
+            if (i[0] === 3 && (!t || i[1] > t[0] && i[1] < t[3])) {
+              e.label = i[1];
+              break;
+            }
+            if (i[0] === 6 && e.label < t[1]) {
+              e.label = t[1], t = i;
+              break;
+            }
+            if (t && e.label < t[2]) {
+              e.label = t[2], e.ops.push(i);
+              break;
+            }
+            t[2] && e.ops.pop(), e.trys.pop();
+            continue;
+        }
+        i = n.call(u, e);
+      } catch (y) {
+        i = [6, y], r = 0;
+      } finally {
+        s = t = 0;
+      }
+      if (i[0] & 5) throw i[1];
+      return { value: i[0] ? i[1] : void 0, done: !0 };
+    }
+  };
+  Object.defineProperty(h, "__esModule", { value: !0 }), h.useUnityContext = void 0;
+  var a = g, v = Z(), f = be(), m = _e(), U = function(u) {
+    var n = (0, m.useNullableState)(), e = n[0], s = n[1], r = (0, a.useState)(0), t = r[0], d = r[1], b = (0, a.useState)(!1), o = b[0], i = b[1], y = (0, m.useNullableState)(), C = y[0], ee = y[1], A = (0, f.useEventSystem)(), te = (0, a.useRef)({
+      setLoadingProgression: d,
+      setInitialisationError: ee,
+      setUnityInstance: s,
+      setIsLoaded: i,
+      unityConfig: u
+    }), ne = (0, a.useCallback)(
+      /**
+       * @param enabled Defines whether Unity should be in fullscreen.
+       */
+      function(_) {
+        if (e === null) {
+          console.warn(v.errorMessages.requestFullscreenNoUnityInstance);
+          return;
+        }
+        e.SetFullscreen(_ === !0 ? 1 : 0);
+      },
+      [e]
+    ), re = (0, a.useCallback)(function() {
+      if (e === null || typeof e.Module.canvas > "u") {
+        console.warn(v.errorMessages.requestPointerLockNoUnityInstanceOrCanvas);
+        return;
+      }
+      return e.Module.canvas.requestPointerLock();
+    }, [e]), ae = (0, a.useCallback)(
+      /**
+       * @param gameObjectName the name of the game object in your Unity scene.
+       * @param methodName the name of the public method on the game object.
+       * @param parameter an optional parameter to pass along to the method.
+       */
+      function(_, I, ue) {
+        if (e === null) {
+          console.warn(v.errorMessages.sendMessageNoUnityInstance);
+          return;
+        }
+        e.SendMessage(_, I, ue);
+      },
+      [e]
+    ), ie = (0, a.useCallback)(
+      /**
+       * @param dataType Defines the type of screenshot to take.
+       * @param quality Defines the quality of the screenshot.
+       * @returns A base 64 encoded string of the screenshot.
+       */
+      function(_, I) {
+        if (e === null || typeof e.Module.canvas > "u") {
+          console.warn(v.errorMessages.screenshotNoUnityInstanceOrCanvas);
+          return;
+        }
+        return e.Module.canvas.toDataURL(_, I);
+      },
+      [e]
+    ), O = (0, a.useCallback)(
+      /**
+       * @returns A promise that resolves when the UnityInstance has been unloaded.
+       */
+      function() {
+        return e === null ? (console.warn(v.errorMessages.quitNoUnityInstance), Promise.reject()) : e.Quit();
+      },
+      [e]
+    ), se = (0, a.useCallback)(
+      /**
+       * @returns A promise that resolves when the UnityInstance has been unloaded.
+       */
+      function() {
+        return l(void 0, void 0, void 0, function() {
+          var _;
+          return c(this, function(I) {
+            switch (I.label) {
+              case 0:
+                return e === null || typeof e.Module.canvas > "u" ? (console.warn(v.errorMessages.genericNoUnityInstance), [2, Promise.reject()]) : (_ = e.Module.canvas, document.body.appendChild(_), _.style.display = "none", [4, O()]);
+              case 1:
+                return I.sent(), _.remove(), [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      },
+      [e]
+    );
+    return (0, a.useEffect)(function() {
+      i(t === 1);
+    }, [t]), {
+      unityProvider: te.current,
+      loadingProgression: t,
+      initialisationError: C,
+      isLoaded: o,
+      UNSAFE__unityInstance: e,
+      requestFullscreen: ne,
+      requestPointerLock: re,
+      sendMessage: ae,
+      takeScreenshot: ie,
+      unload: O,
+      UNSAFE__detachAndUnloadImmediate: se,
+      addEventListener: A.addEventListener,
+      removeEventListener: A.removeEventListener
+    };
+  };
+  return h.useUnityContext = U, h;
+}
+var K;
+function he() {
+  return K || (K = 1, function(l) {
+    Object.defineProperty(l, "__esModule", { value: !0 }), l.useUnityContext = l.Unity = void 0;
+    var c = me();
+    Object.defineProperty(l, "Unity", { enumerable: !0, get: function() {
+      return c.Unity;
+    } });
+    var a = we();
+    Object.defineProperty(l, "useUnityContext", { enumerable: !0, get: function() {
+      return a.useUnityContext;
+    } });
+  }(j)), j;
+}
+var X = he();
+const Ce = le.forwardRef(
+  ({ className: l, gameLink: c, loadingComponent: a }, v) => {
+    const { unityProvider: f, isLoaded: m, loadingProgression: U, UNSAFE__unityInstance: u } = X.useUnityContext({
+      loaderUrl: `${c}/Build/Build.loader.js`,
+      dataUrl: `${c}/Build/Build.data.unityweb`,
+      frameworkUrl: `${c}/Build/Build.framework.js.unityweb`,
+      codeUrl: `${c}/Build/Build.wasm.unityweb`
+    });
+    return ce(() => {
+      window && u && (window.unityInstance = u);
+    }, [u]), /* @__PURE__ */ P(oe, { children: [
+      !m && (a ? /* @__PURE__ */ $(a, { progress: U }) : /* @__PURE__ */ P("div", { className: "h-full w-full items-center justify-center text-center", children: [
+        "Loading $",
+        U * 100,
+        "%"
+      ] })),
+      /* @__PURE__ */ $(
+        X.Unity,
+        {
+          ref: v,
+          id: "unity-canvas",
+          unityProvider: f,
+          className: de(l, !m && "hidden"),
+          devicePixelRatio: (window == null ? void 0 : window.devicePixelRatio) || 1
+        }
+      )
+    ] });
+  }
+);
+export {
+  Ce as UnityGame
+};

package/dist/gql/fragment-masking.d.ts

@@ -0,0 +1,19 @@
+import { ResultOf, DocumentTypeDecoration, TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { Incremental } from './graphql';
+export type FragmentType<TDocumentType extends DocumentTypeDecoration<any, any>> = TDocumentType extends DocumentTypeDecoration<infer TType, any> ? [TType] extends [{
+    ' $fragmentName'?: infer TKey;
+}] ? TKey extends string ? {
+    ' $fragmentRefs'?: {
+        [key in TKey]: TType;
+    };
+} : never : never : never;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>>): TType;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | undefined): TType | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null): TType | null;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null | undefined): TType | null | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>>): Array<TType>;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): Array<TType> | null | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>>): ReadonlyArray<TType>;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): ReadonlyArray<TType> | null | undefined;
+export declare function makeFragmentData<F extends DocumentTypeDecoration<any, any>, FT extends ResultOf<F>>(data: FT, _fragment: F): FragmentType<F>;
+export declare function isFragmentReady<TQuery, TFrag>(queryNode: DocumentTypeDecoration<TQuery, any>, fragmentNode: TypedDocumentNode<TFrag>, data: FragmentType<TypedDocumentNode<Incremental<TFrag>, any>> | null | undefined): data is FragmentType<typeof fragmentNode>;