@cruglobal/cornerstone-components 0.1.2 → 0.1.3

package/dist/bundled/chunks/chunk.ONECUKXL.js

@@ -0,0 +1,227 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  CsStartEvent
+} from "./chunk.RIWHUCNB.js";
+import {
+  CsFinishEvent
+} from "./chunk.AZ4Y33KB.js";
+import {
+  CsCancelEvent
+} from "./chunk.Q4TNHGOA.js";
+import {
+  animation_styles_default
+} from "./chunk.HZBDVNYT.js";
+import {
+  dist_exports
+} from "./chunk.BEQXAGOI.js";
+import {
+  watch
+} from "./chunk.MBVC472U.js";
+import {
+  CornerstoneElement,
+  customElement,
+  n,
+  r2 as r
+} from "./chunk.JHAHINDP.js";
+import {
+  b
+} from "./chunk.TYX6K4EU.js";
+import {
+  __decorateClass
+} from "./chunk.OPDM4EQH.js";
+
+// src/components/animation/animation.ts
+var CsAnimation = class extends CornerstoneElement {
+  constructor() {
+    super(...arguments);
+    this.hasStarted = false;
+    this.name = "none";
+    this.play = false;
+    this.delay = 0;
+    this.direction = "normal";
+    this.duration = 1e3;
+    this.easing = "linear";
+    this.endDelay = 0;
+    this.fill = "auto";
+    this.iterations = Infinity;
+    this.iterationStart = 0;
+    this.playbackRate = 1;
+    this.handleAnimationFinish = () => {
+      this.play = false;
+      this.hasStarted = false;
+      this.dispatchEvent(new CsFinishEvent());
+    };
+    this.handleAnimationCancel = () => {
+      this.play = false;
+      this.hasStarted = false;
+      this.dispatchEvent(new CsCancelEvent());
+    };
+  }
+  /** Gets and sets the current animation time. */
+  get currentTime() {
+    return this.animation?.currentTime ?? 0;
+  }
+  set currentTime(time) {
+    if (this.animation) {
+      this.animation.currentTime = time;
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if ("animate" in this) {
+      this.createAnimation();
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    if ("animate" in this) {
+      this.destroyAnimation();
+    }
+  }
+  handleSlotChange() {
+    this.destroyAnimation();
+    this.createAnimation();
+  }
+  async createAnimation() {
+    const easing = dist_exports.easings[this.easing] ?? this.easing;
+    const keyframes = this.keyframes ?? dist_exports[this.name];
+    const slot = await this.defaultSlot;
+    const element = slot.assignedElements()[0];
+    if (!element || !keyframes) {
+      return false;
+    }
+    this.destroyAnimation();
+    this.animation = element.animate(keyframes, {
+      delay: this.delay,
+      direction: this.direction,
+      duration: this.duration,
+      easing,
+      endDelay: this.endDelay,
+      fill: this.fill,
+      iterationStart: this.iterationStart,
+      iterations: this.iterations
+    });
+    this.animation.playbackRate = this.playbackRate;
+    this.animation.addEventListener("cancel", this.handleAnimationCancel);
+    this.animation.addEventListener("finish", this.handleAnimationFinish);
+    if (this.play) {
+      this.hasStarted = true;
+      this.dispatchEvent(new CsStartEvent());
+    } else {
+      this.animation.pause();
+    }
+    return true;
+  }
+  destroyAnimation() {
+    if (this.animation) {
+      this.animation.cancel();
+      this.animation.removeEventListener("cancel", this.handleAnimationCancel);
+      this.animation.removeEventListener("finish", this.handleAnimationFinish);
+      this.hasStarted = false;
+    }
+  }
+  handleAnimationChange() {
+    if (!this.hasUpdated) {
+      return;
+    }
+    this.createAnimation();
+  }
+  handlePlayChange() {
+    if (this.animation) {
+      if (this.play && !this.hasStarted) {
+        this.hasStarted = true;
+        this.dispatchEvent(new CsStartEvent());
+      }
+      if (this.play) {
+        this.animation.play();
+      } else {
+        this.animation.pause();
+      }
+      return true;
+    }
+    return false;
+  }
+  handlePlaybackRateChange() {
+    if (this.animation) {
+      this.animation.playbackRate = this.playbackRate;
+    }
+  }
+  /** Clears all keyframe effects caused by this animation and aborts its playback. */
+  cancel() {
+    this.animation?.cancel();
+  }
+  /** Sets the playback time to the end of the animation corresponding to the current playback direction. */
+  finish() {
+    this.animation?.finish();
+  }
+  render() {
+    return b` <slot @slotchange=${this.handleSlotChange}></slot> `;
+  }
+};
+CsAnimation.css = animation_styles_default;
+__decorateClass([
+  r("slot")
+], CsAnimation.prototype, "defaultSlot", 2);
+__decorateClass([
+  n()
+], CsAnimation.prototype, "name", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], CsAnimation.prototype, "play", 2);
+__decorateClass([
+  n({ type: Number })
+], CsAnimation.prototype, "delay", 2);
+__decorateClass([
+  n()
+], CsAnimation.prototype, "direction", 2);
+__decorateClass([
+  n({ type: Number })
+], CsAnimation.prototype, "duration", 2);
+__decorateClass([
+  n()
+], CsAnimation.prototype, "easing", 2);
+__decorateClass([
+  n({ attribute: "end-delay", type: Number })
+], CsAnimation.prototype, "endDelay", 2);
+__decorateClass([
+  n()
+], CsAnimation.prototype, "fill", 2);
+__decorateClass([
+  n({ type: Number })
+], CsAnimation.prototype, "iterations", 2);
+__decorateClass([
+  n({ attribute: "iteration-start", type: Number })
+], CsAnimation.prototype, "iterationStart", 2);
+__decorateClass([
+  n({ attribute: false })
+], CsAnimation.prototype, "keyframes", 2);
+__decorateClass([
+  n({ attribute: "playback-rate", type: Number })
+], CsAnimation.prototype, "playbackRate", 2);
+__decorateClass([
+  watch([
+    "name",
+    "delay",
+    "direction",
+    "duration",
+    "easing",
+    "endDelay",
+    "fill",
+    "iterations",
+    "iterationsStart",
+    "keyframes"
+  ])
+], CsAnimation.prototype, "handleAnimationChange", 1);
+__decorateClass([
+  watch("play")
+], CsAnimation.prototype, "handlePlayChange", 1);
+__decorateClass([
+  watch("playbackRate")
+], CsAnimation.prototype, "handlePlaybackRateChange", 1);
+CsAnimation = __decorateClass([
+  customElement("cs-animation")
+], CsAnimation);
+
+export {
+  CsAnimation
+};

package/dist/bundled/chunks/chunk.ONVQC3CB.js

@@ -0,0 +1,29 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  o,
+  require_react
+} from "./chunk.R6QGWT6N.js";
+import {
+  CsTree
+} from "./chunk.FXNUG4HO.js";
+import {
+  __toESM
+} from "./chunk.OPDM4EQH.js";
+
+// src/react/tree/index.ts
+var React = __toESM(require_react(), 1);
+var tagName = "cs-tree";
+var reactWrapper = o({
+  tagName,
+  elementClass: CsTree,
+  react: React,
+  events: {
+    onCsSelectionChange: "cs-selection-change"
+  },
+  displayName: "CsTree"
+});
+var tree_default = reactWrapper;
+
+export {
+  tree_default
+};

package/dist/bundled/chunks/chunk.OP25RW37.js

@@ -0,0 +1,36 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// ../../node_modules/lit-html/directive.js
+var t = { ATTRIBUTE: 1, CHILD: 2, PROPERTY: 3, BOOLEAN_ATTRIBUTE: 4, EVENT: 5, ELEMENT: 6 };
+var e = (t2) => (...e2) => ({ _$litDirective$: t2, values: e2 });
+var i = class {
+  constructor(t2) {
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AT(t2, e2, i2) {
+    this._$Ct = t2, this._$AM = e2, this._$Ci = i2;
+  }
+  _$AS(t2, e2) {
+    return this.update(t2, e2);
+  }
+  update(t2, e2) {
+    return this.render(...e2);
+  }
+};
+
+export {
+  t,
+  e,
+  i
+};
+/*! Bundled license information:
+
+lit-html/directive.js:
+  (**
+   * @license
+   * Copyright 2017 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/

package/dist/bundled/chunks/chunk.OPDM4EQH.js

@@ -0,0 +1,64 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __commonJS,
+  __export,
+  __toESM,
+  __decorateClass,
+  __publicField,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod
+};