regl-web-components 0.0.1 → 0.3.0

package/dist/all.js

@@ -9777,65 +9777,6 @@ var require_regl = __commonJS({
   }
 });
 
-// src/regl-element.ts
-var import_regl = __toESM(require_regl());
-
-// src/regl-wc-initialization-options.ts
-var regl_wc_initialization_options_default = reglWcInitializationOptions;
-function reglWcInitializationOptions(element) {
-  const optionsAttrJson = element.getAttribute("initializationOptions");
-  const optionsFromAttrs = [
-    {
-      attribute: "canvas",
-      getValue: (id) => document.getElementById(id)
-    },
-    {
-      attribute: "container",
-      getValue: (id) => document.getElementById(id)
-    },
-    {
-      attribute: "pixelRatio",
-      getValue: (attr) => +attr
-    }
-  ].map((spec) => {
-    const attr = element.getAttribute(spec.attribute);
-    if (attr) return { [spec.attribute]: spec.getValue(attr) };
-    return null;
-  }).filter((v) => !!v).reduce((accum, kv) => {
-    return {
-      ...accum,
-      ...kv
-    };
-  }, {});
-  const options = {
-    ...optionsAttrJson ? JSON.parse(optionsAttrJson) : {},
-    ...optionsFromAttrs,
-    ...element.reglInitializationOptions
-  };
-  return {
-    ...options,
-    ...!options.container && !options.canvas ? { container: element } : {}
-  };
-}
-
-// src/regl-element.ts
-var ReglElement = class extends HTMLElement {
-  regl;
-  get reglInitializationOptions() {
-    return {};
-  }
-  createRegl() {
-    const options = regl_wc_initialization_options_default(this);
-    this.regl = (0, import_regl.default)(options);
-  }
-  connectedCallback() {
-    this.createRegl();
-  }
-  disconnectedCallback() {
-    this?.regl?.destroy();
-  }
-};
-
 // src/deferred-regl.ts
 var deferred_regl_default = deferredRegl;
 function deferredRegl() {
@@ -10014,6 +9955,65 @@ function falsy(x) {
   return x === null || x === void 0;
 }
 
+// src/regl-element.ts
+var import_regl = __toESM(require_regl());
+
+// src/regl-wc-initialization-options.ts
+var regl_wc_initialization_options_default = reglWcInitializationOptions;
+function reglWcInitializationOptions(element) {
+  const optionsAttrJson = element.getAttribute("initializationOptions");
+  const optionsFromAttrs = [
+    {
+      attribute: "canvas",
+      getValue: (id) => document.getElementById(id)
+    },
+    {
+      attribute: "container",
+      getValue: (id) => document.getElementById(id)
+    },
+    {
+      attribute: "pixelRatio",
+      getValue: (attr) => +attr
+    }
+  ].map((spec) => {
+    const attr = element.getAttribute(spec.attribute);
+    if (attr) return { [spec.attribute]: spec.getValue(attr) };
+    return null;
+  }).filter((v) => !!v).reduce((accum, kv) => {
+    return {
+      ...accum,
+      ...kv
+    };
+  }, {});
+  const options = {
+    ...optionsAttrJson ? JSON.parse(optionsAttrJson) : {},
+    ...optionsFromAttrs,
+    ...element.reglInitializationOptions
+  };
+  return {
+    ...options,
+    ...!options.container && !options.canvas ? { container: element } : {}
+  };
+}
+
+// src/regl-element.ts
+var ReglElement = class extends HTMLElement {
+  regl;
+  get reglInitializationOptions() {
+    return {};
+  }
+  createRegl() {
+    const options = regl_wc_initialization_options_default(this);
+    this.regl = (0, import_regl.default)(options);
+  }
+  connectedCallback() {
+    this.createRegl();
+  }
+  disconnectedCallback() {
+    this?.regl?.destroy();
+  }
+};
+
 // src/regl-multi-root.ts
 var import_regl2 = __toESM(require_regl());
 
@@ -10319,5 +10319,6 @@ var ReglMultiElement = class extends HTMLElement {
 export {
   ReglElement,
   ReglMultiElement,
-  ReglMultiRoot
+  ReglMultiRoot,
+  deferredRegl
 };

package/dist/deferred-regl.cjs

@@ -0,0 +1,201 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/deferred-regl.ts
+var deferred_regl_exports = {};
+__export(deferred_regl_exports, {
+  default: () => deferred_regl_default,
+  deferredRegl: () => deferredRegl
+});
+module.exports = __toCommonJS(deferred_regl_exports);
+var deferred_regl_default = deferredRegl;
+function deferredRegl() {
+  var regl = null;
+  var queue = [];
+  var def = dfn("()");
+  unset();
+  def.setRegl = function(r) {
+    regl = r;
+    if (!r) return unset();
+    for (var i = 0; i < queue.length; i++) {
+      queue[i](regl);
+    }
+    queue = null;
+    def.frame = r.frame;
+    def.draw = r.draw;
+    def.poll = r.poll;
+    def.clear = r.clear;
+    def.buffer = r.buffer;
+    def.texture = r.texture;
+    def.elements = r.elements;
+    def.framebuffer = r.framebuffer;
+    def.framebufferCube = r.framebufferCube;
+    def.renderbuffer = r.renderbuffer;
+    def.cube = r.cube;
+    def.read = r.read;
+    def.hasExtension = r.hasExtension;
+    def.limits = r.limits;
+    def.stats = r.limits;
+    def.now = r.now;
+    def.destroy = r.destroy;
+    def.on = r.on;
+  };
+  return def;
+  function unset() {
+    if (!queue) queue = [];
+    def.frame = function(cb) {
+      queue.push(function(r) {
+        r.frame(cb);
+      });
+    };
+    def.draw = function(cb) {
+      queue.push(function(r) {
+        r.draw(cb);
+      });
+    };
+    def.poll = function() {
+      queue.push(function(r) {
+        r.poll();
+      });
+    };
+    def.clear = function(opts) {
+      queue.push(function(r) {
+        r.clear(opts);
+      });
+    };
+    def.prop = function(key) {
+      return function(context, props) {
+        if (!falsy(props[key])) {
+          return props[key];
+        } else {
+          var matches = key.match(/(?<prop>.+)\[(?<index>.+)\]/i);
+          if (matches) {
+            return props[matches.groups.prop][matches.groups.index];
+          }
+        }
+      };
+    };
+    def.props = def.prop;
+    def.context = function(key) {
+      return function(context, props) {
+        return context[key];
+      };
+    };
+    def["this"] = function(key) {
+      return function(context, props) {
+        return this[key];
+      };
+    };
+    def.buffer = dfn("buffer");
+    def.texture = dfn("texture");
+    def.elements = dfn("elements");
+    def.framebuffer = dfnx("framebuffer", ["resize", "use"]);
+    def.framebufferCube = dfn("framebufferCube");
+    def.renderbuffer = dfn("renderbuffer");
+    def.cube = dfn("cube");
+    def.read = function() {
+    };
+    def.hasExtension = function() {
+    };
+    def.limits = function() {
+    };
+    def.stats = function() {
+    };
+    def.now = function() {
+      return 0;
+    };
+    def.destroy = function() {
+      queue.push(function(r) {
+        r.destroy();
+      });
+    };
+    def.on = function(name, f) {
+      queue.push(function(r) {
+        r.on(name, f);
+      });
+    };
+  }
+  function dfn(key) {
+    return function(opts) {
+      if (key === "()" && regl) return regl(opts);
+      else if (regl) return regl[key](opts);
+      var f = null;
+      if (key === "()") {
+        queue.push(function(r) {
+          f = r(opts);
+        });
+      } else {
+        queue.push(function(r) {
+          f = r[key](opts);
+        });
+      }
+      return function() {
+        var args = arguments;
+        if (!falsy(f)) {
+          if (key === "()") f.apply(null, args);
+          else return f;
+        } else {
+          queue.push(function(r) {
+            f.apply(null, args);
+          });
+        }
+      };
+    };
+  }
+  function dfnx(key, methods) {
+    return function(opts) {
+      if (key === "()" && regl) return regl(opts);
+      else if (regl) return regl[key](opts);
+      var f = null;
+      if (key === "()") {
+        queue.push(function(r2) {
+          f = r2(opts);
+        });
+      } else {
+        queue.push(function(r2) {
+          f = r2[key](opts);
+        });
+      }
+      var r = function() {
+        var args = arguments;
+        if (!falsy(f)) {
+          if (key === "()") f.apply(null, args);
+          else return f;
+        } else {
+          queue.push(function(r2) {
+            f.apply(null, args);
+          });
+        }
+      };
+      for (var i = 0; i < methods.length; i++) {
+        var m = methods[i];
+        r[m] = function() {
+          var args = arguments;
+          if (!falsy(f)) return f[m].apply(f, args);
+          else queue.push(function() {
+            f[m].apply(f, args);
+          });
+        };
+      }
+      return r;
+    };
+  }
+}
+function falsy(x) {
+  return x === null || x === void 0;
+}

package/dist/deferred-regl.js

@@ -0,0 +1,181 @@
+// src/deferred-regl.ts
+var deferred_regl_default = deferredRegl;
+function deferredRegl() {
+  var regl = null;
+  var queue = [];
+  var def = dfn("()");
+  unset();
+  def.setRegl = function(r) {
+    regl = r;
+    if (!r) return unset();
+    for (var i = 0; i < queue.length; i++) {
+      queue[i](regl);
+    }
+    queue = null;
+    def.frame = r.frame;
+    def.draw = r.draw;
+    def.poll = r.poll;
+    def.clear = r.clear;
+    def.buffer = r.buffer;
+    def.texture = r.texture;
+    def.elements = r.elements;
+    def.framebuffer = r.framebuffer;
+    def.framebufferCube = r.framebufferCube;
+    def.renderbuffer = r.renderbuffer;
+    def.cube = r.cube;
+    def.read = r.read;
+    def.hasExtension = r.hasExtension;
+    def.limits = r.limits;
+    def.stats = r.limits;
+    def.now = r.now;
+    def.destroy = r.destroy;
+    def.on = r.on;
+  };
+  return def;
+  function unset() {
+    if (!queue) queue = [];
+    def.frame = function(cb) {
+      queue.push(function(r) {
+        r.frame(cb);
+      });
+    };
+    def.draw = function(cb) {
+      queue.push(function(r) {
+        r.draw(cb);
+      });
+    };
+    def.poll = function() {
+      queue.push(function(r) {
+        r.poll();
+      });
+    };
+    def.clear = function(opts) {
+      queue.push(function(r) {
+        r.clear(opts);
+      });
+    };
+    def.prop = function(key) {
+      return function(context, props) {
+        if (!falsy(props[key])) {
+          return props[key];
+        } else {
+          var matches = key.match(/(?<prop>.+)\[(?<index>.+)\]/i);
+          if (matches) {
+            return props[matches.groups.prop][matches.groups.index];
+          }
+        }
+      };
+    };
+    def.props = def.prop;
+    def.context = function(key) {
+      return function(context, props) {
+        return context[key];
+      };
+    };
+    def["this"] = function(key) {
+      return function(context, props) {
+        return this[key];
+      };
+    };
+    def.buffer = dfn("buffer");
+    def.texture = dfn("texture");
+    def.elements = dfn("elements");
+    def.framebuffer = dfnx("framebuffer", ["resize", "use"]);
+    def.framebufferCube = dfn("framebufferCube");
+    def.renderbuffer = dfn("renderbuffer");
+    def.cube = dfn("cube");
+    def.read = function() {
+    };
+    def.hasExtension = function() {
+    };
+    def.limits = function() {
+    };
+    def.stats = function() {
+    };
+    def.now = function() {
+      return 0;
+    };
+    def.destroy = function() {
+      queue.push(function(r) {
+        r.destroy();
+      });
+    };
+    def.on = function(name, f) {
+      queue.push(function(r) {
+        r.on(name, f);
+      });
+    };
+  }
+  function dfn(key) {
+    return function(opts) {
+      if (key === "()" && regl) return regl(opts);
+      else if (regl) return regl[key](opts);
+      var f = null;
+      if (key === "()") {
+        queue.push(function(r) {
+          f = r(opts);
+        });
+      } else {
+        queue.push(function(r) {
+          f = r[key](opts);
+        });
+      }
+      return function() {
+        var args = arguments;
+        if (!falsy(f)) {
+          if (key === "()") f.apply(null, args);
+          else return f;
+        } else {
+          queue.push(function(r) {
+            f.apply(null, args);
+          });
+        }
+      };
+    };
+  }
+  function dfnx(key, methods) {
+    return function(opts) {
+      if (key === "()" && regl) return regl(opts);
+      else if (regl) return regl[key](opts);
+      var f = null;
+      if (key === "()") {
+        queue.push(function(r2) {
+          f = r2(opts);
+        });
+      } else {
+        queue.push(function(r2) {
+          f = r2[key](opts);
+        });
+      }
+      var r = function() {
+        var args = arguments;
+        if (!falsy(f)) {
+          if (key === "()") f.apply(null, args);
+          else return f;
+        } else {
+          queue.push(function(r2) {
+            f.apply(null, args);
+          });
+        }
+      };
+      for (var i = 0; i < methods.length; i++) {
+        var m = methods[i];
+        r[m] = function() {
+          var args = arguments;
+          if (!falsy(f)) return f[m].apply(f, args);
+          else queue.push(function() {
+            f[m].apply(f, args);
+          });
+        };
+      }
+      return r;
+    };
+  }
+}
+function falsy(x) {
+  return x === null || x === void 0;
+}
+export {
+  deferred_regl_default as default,
+  deferredRegl
+};