@gez/date-time-kit/dist/components/web-component-base/index.mjs

var __freeze = Object.freeze;
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __template = (cooked, raw) => __freeze(__defProp(cooked, "raw", { value: __freeze(raw || cooked.slice()) }));
var _a;
import { debounce, smallScreenObserver } from "../../utils/index.mjs";
import { scrollbarStyleStr, styleStr } from "./css.mjs";
const templateCache = /* @__PURE__ */ new Map();
if (typeof document === "object") {
  try {
    const styleSheet = new CSSStyleSheet();
    styleSheet.replaceSync(scrollbarStyleStr);
    document.adoptedStyleSheets.unshift(styleSheet);
  } catch (e) {
    const styleEle = document.createElement("style");
    styleEle.innerHTML = scrollbarStyleStr;
    document.head.prepend(styleEle);
  }
}
const HTMLElementBase = (() => {
  if (typeof HTMLElement === "function") return HTMLElement;
  return class {
  };
})();
export class UiBase extends HTMLElementBase {
  constructor() {
    super();
    __publicField(this, "_staticElsCache");
    __publicField(this, "_unbindFnCache", []);
    __publicField(this, "_stopEvent", (e) => e.stopPropagation());
    const shadowRoot = this.attachShadow({ mode: "open" });
    shadowRoot.innerHTML = "";
    shadowRoot.appendChild(this._initTemplate().content.cloneNode(true));
    this._staticElsCache = this._staticEls;
  }
  static define() {
    if (this._definePromise) return this._definePromise;
    if (typeof customElements === "undefined") {
      return;
    }
    const tagName = this.tagName;
    if (!tagName) throw new Error("UiBase.define: tagName is not defined.");
    this._definePromise = customElements.whenDefined(tagName);
    customElements.define(tagName, this);
    return this._definePromise;
  }
  // TODO: use override keyword in subclasses
  static get observedAttributes() {
    return ["lang"];
  }
  get _constructor() {
    return this.constructor;
  }
  _initTemplate() {
    const { tagName } = this;
    if (templateCache.has(tagName)) return templateCache.get(tagName);
    const templateEle = document.createElement("template");
    templateEle.innerHTML = "<style>".concat(scrollbarStyleStr).concat(styleStr).concat(this._constructor._style, "</style>").concat(this._constructor._template);
    templateCache.set(tagName, templateEle);
    return templateEle;
  }
  get _staticEls() {
    return /* @__PURE__ */ Object.create(null);
  }
  get _dynamicEls() {
    return /* @__PURE__ */ Object.create(null);
  }
  get _els() {
    return Object.assign({}, this._staticElsCache, this._dynamicEls);
  }
  _getAttr(qualifiedName, defaultValue) {
    const attr = this.getAttribute(qualifiedName);
    return attr === null && defaultValue !== void 0 ? defaultValue : attr;
  }
  $(selector, ...args) {
    var _a2;
    if (typeof selector !== "string")
      selector = String.raw(selector, ...args);
    return [...((_a2 = this.shadowRoot) == null ? void 0 : _a2.querySelectorAll(selector)) || []];
  }
  $0(selector, ...args) {
    return this.$(selector, ...args)[0];
  }
  _bindEvt(elsOrSelector, ...strSlot) {
    const els = typeof elsOrSelector === "string" ? this.$(elsOrSelector) : !Array.isArray(elsOrSelector) ? [elsOrSelector] : typeof elsOrSelector[0] === "string" ? this.$(elsOrSelector, ...strSlot) : elsOrSelector;
    return ((...args) => {
      els.forEach((el) => {
        el.addEventListener(...args);
        this._unbindFnCache.push(() => el.removeEventListener(...args));
      });
    });
  }
  _onAttrChanged(_name, _oldVal, _newVal) {
  }
  attributeChangedCallback(name, oldValue, newValue) {
    if (oldValue === newValue) return;
    this._onAttrChanged(name, oldValue, newValue);
    this.dispatchEvent(
      "dt-attribute-changed",
      { name, oldValue, newValue },
      true
    );
    if (name === "lang")
      this.$(_a || (_a = __template(["[dt]"]))).forEach((ele) => {
        if (newValue) ele.setAttribute("lang", newValue);
        else ele.removeAttribute("lang");
      });
  }
  /** return `false | void` means not continue */
  connectedCallback() {
    this.setAttribute("dt", "");
    smallScreenObserver.observe(this, this._onScreenSizeChanged.bind(this));
    return !!this.shadowRoot;
  }
  /** return `false | void` means not continue */
  disconnectedCallback() {
    smallScreenObserver.unobserve(this);
    this._unbindFnCache.forEach((fn) => fn());
    this._unbindFnCache = [];
    return !!this.shadowRoot;
  }
  connectedMoveCallback() {
  }
  adoptedCallback() {
  }
  _onScreenSizeChanged(isSmall) {
  }
  get _isSmallScreen() {
    return smallScreenObserver.isSmall;
  }
  dispatchEvent(type, data, global = false) {
    return type instanceof Event ? super.dispatchEvent(type) : super.dispatchEvent(
      new CustomEvent(type, {
        ...global ? {
          bubbles: true,
          cancelable: true,
          composed: true
        } : {},
        detail: data
      })
    );
  }
  addEventListener(type, listener, options) {
    super.addEventListener(
      type,
      listener,
      options
    );
  }
  removeEventListener(type, listener, options) {
    super.removeEventListener(
      type,
      listener,
      options
    );
  }
  _genRenderFn(fn) {
    return debounce((...args) => {
      if (!this.isConnected) return;
      fn(...args);
    }, 0);
  }
}
__publicField(UiBase, "tagName", "");
__publicField(UiBase, "_definePromise", null);
__publicField(UiBase, "_style", "");
__publicField(UiBase, "_template", "");