masoneffect 1.0.29 → 2.0.1

package/dist/svelte/count/index.mjs

@@ -0,0 +1,659 @@
+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);
+import { createEventDispatcher, onMount, onDestroy } from "svelte";
+function noop() {
+}
+function run(fn) {
+  return fn();
+}
+function blank_object() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function run_all(fns) {
+  fns.forEach(run);
+}
+function is_function(thing) {
+  return typeof thing === "function";
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
+}
+function is_empty(obj) {
+  return Object.keys(obj).length === 0;
+}
+function insert(target, node, anchor) {
+  target.insertBefore(node, anchor || null);
+}
+function detach(node) {
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+}
+function element(name) {
+  return document.createElement(name);
+}
+function attr(node, attribute, value) {
+  if (value == null) node.removeAttribute(attribute);
+  else if (node.getAttribute(attribute) !== value) node.setAttribute(attribute, value);
+}
+function children(element2) {
+  return Array.from(element2.childNodes);
+}
+let current_component;
+function set_current_component(component) {
+  current_component = component;
+}
+const dirty_components = [];
+const binding_callbacks = [];
+let render_callbacks = [];
+const flush_callbacks = [];
+const resolved_promise = /* @__PURE__ */ Promise.resolve();
+let update_scheduled = false;
+function schedule_update() {
+  if (!update_scheduled) {
+    update_scheduled = true;
+    resolved_promise.then(flush);
+  }
+}
+function add_render_callback(fn) {
+  render_callbacks.push(fn);
+}
+const seen_callbacks = /* @__PURE__ */ new Set();
+let flushidx = 0;
+function flush() {
+  if (flushidx !== 0) {
+    return;
+  }
+  const saved_component = current_component;
+  do {
+    try {
+      while (flushidx < dirty_components.length) {
+        const component = dirty_components[flushidx];
+        flushidx++;
+        set_current_component(component);
+        update(component.$$);
+      }
+    } catch (e) {
+      dirty_components.length = 0;
+      flushidx = 0;
+      throw e;
+    }
+    set_current_component(null);
+    dirty_components.length = 0;
+    flushidx = 0;
+    while (binding_callbacks.length) binding_callbacks.pop()();
+    for (let i = 0; i < render_callbacks.length; i += 1) {
+      const callback = render_callbacks[i];
+      if (!seen_callbacks.has(callback)) {
+        seen_callbacks.add(callback);
+        callback();
+      }
+    }
+    render_callbacks.length = 0;
+  } while (dirty_components.length);
+  while (flush_callbacks.length) {
+    flush_callbacks.pop()();
+  }
+  update_scheduled = false;
+  seen_callbacks.clear();
+  set_current_component(saved_component);
+}
+function update($$) {
+  if ($$.fragment !== null) {
+    $$.update();
+    run_all($$.before_update);
+    const dirty = $$.dirty;
+    $$.dirty = [-1];
+    $$.fragment && $$.fragment.p($$.ctx, dirty);
+    $$.after_update.forEach(add_render_callback);
+  }
+}
+function flush_render_callbacks(fns) {
+  const filtered = [];
+  const targets = [];
+  render_callbacks.forEach((c) => fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c));
+  targets.forEach((c) => c());
+  render_callbacks = filtered;
+}
+const outroing = /* @__PURE__ */ new Set();
+function transition_in(block, local) {
+  if (block && block.i) {
+    outroing.delete(block);
+    block.i(local);
+  }
+}
+function mount_component(component, target, anchor) {
+  const { fragment, after_update } = component.$$;
+  fragment && fragment.m(target, anchor);
+  add_render_callback(() => {
+    const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
+    if (component.$$.on_destroy) {
+      component.$$.on_destroy.push(...new_on_destroy);
+    } else {
+      run_all(new_on_destroy);
+    }
+    component.$$.on_mount = [];
+  });
+  after_update.forEach(add_render_callback);
+}
+function destroy_component(component, detaching) {
+  const $$ = component.$$;
+  if ($$.fragment !== null) {
+    flush_render_callbacks($$.after_update);
+    run_all($$.on_destroy);
+    $$.fragment && $$.fragment.d(detaching);
+    $$.on_destroy = $$.fragment = null;
+    $$.ctx = [];
+  }
+}
+function make_dirty(component, i) {
+  if (component.$$.dirty[0] === -1) {
+    dirty_components.push(component);
+    schedule_update();
+    component.$$.dirty.fill(0);
+  }
+  component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
+}
+function init(component, options, instance, create_fragment2, not_equal, props, append_styles = null, dirty = [-1]) {
+  const parent_component = current_component;
+  set_current_component(component);
+  const $$ = component.$$ = {
+    fragment: null,
+    ctx: [],
+    // state
+    props,
+    update: noop,
+    not_equal,
+    bound: blank_object(),
+    // lifecycle
+    on_mount: [],
+    on_destroy: [],
+    on_disconnect: [],
+    before_update: [],
+    after_update: [],
+    context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
+    // everything else
+    callbacks: blank_object(),
+    dirty,
+    skip_bound: false,
+    root: options.target || parent_component.$$.root
+  };
+  append_styles && append_styles($$.root);
+  let ready = false;
+  $$.ctx = instance ? instance(component, options.props || {}, (i, ret, ...rest) => {
+    const value = rest.length ? rest[0] : ret;
+    if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
+      if (!$$.skip_bound && $$.bound[i]) $$.bound[i](value);
+      if (ready) make_dirty(component, i);
+    }
+    return ret;
+  }) : [];
+  $$.update();
+  ready = true;
+  run_all($$.before_update);
+  $$.fragment = create_fragment2 ? create_fragment2($$.ctx) : false;
+  if (options.target) {
+    if (options.hydrate) {
+      const nodes = children(options.target);
+      $$.fragment && $$.fragment.l(nodes);
+      nodes.forEach(detach);
+    } else {
+      $$.fragment && $$.fragment.c();
+    }
+    if (options.intro) transition_in(component.$$.fragment);
+    mount_component(component, options.target, options.anchor);
+    flush();
+  }
+  set_current_component(parent_component);
+}
+class SvelteComponent {
+  constructor() {
+    /**
+     * ### PRIVATE API
+     *
+     * Do not use, may change at any time
+     *
+     * @type {any}
+     */
+    __publicField(this, "$$");
+    /**
+     * ### PRIVATE API
+     *
+     * Do not use, may change at any time
+     *
+     * @type {any}
+     */
+    __publicField(this, "$$set");
+  }
+  /** @returns {void} */
+  $destroy() {
+    destroy_component(this, 1);
+    this.$destroy = noop;
+  }
+  /**
+   * @template {Extract<keyof Events, string>} K
+   * @param {K} type
+   * @param {((e: Events[K]) => void) | null | undefined} callback
+   * @returns {() => void}
+   */
+  $on(type, callback) {
+    if (!is_function(callback)) {
+      return noop;
+    }
+    const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
+    callbacks.push(callback);
+    return () => {
+      const index = callbacks.indexOf(callback);
+      if (index !== -1) callbacks.splice(index, 1);
+    };
+  }
+  /**
+   * @param {Partial<Props>} props
+   * @returns {void}
+   */
+  $set(props) {
+    if (this.$$set && !is_empty(props)) {
+      this.$$.skip_bound = true;
+      this.$$set(props);
+      this.$$.skip_bound = false;
+    }
+  }
+}
+const PUBLIC_VERSION = "4";
+if (typeof window !== "undefined")
+  (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(PUBLIC_VERSION);
+const easingFunctions = {
+  linear: (t) => t
+};
+class Count {
+  constructor(container, options) {
+    this.container = typeof container === "string" ? document.querySelector(container) : container;
+    if (!this.container) {
+      throw new Error("Container element not found");
+    }
+    this.config = {
+      targetValue: options.targetValue,
+      duration: options.duration ?? 2e3,
+      startValue: options.startValue ?? 0,
+      enabled: options.enabled ?? true,
+      easing: options.easing ?? easingFunctions.linear,
+      threshold: options.threshold ?? 0.2,
+      rootMargin: options.rootMargin ?? "0px 0px -100px 0px",
+      triggerOnce: options.triggerOnce ?? false,
+      onUpdate: options.onUpdate || null,
+      onComplete: options.onComplete || null
+    };
+    this.currentValue = this.config.startValue;
+    this.startTime = null;
+    this.animationFrameId = null;
+    this.intersectionObserver = null;
+    this.isRunning = false;
+    this.hasTriggered = false;
+    this.init();
+  }
+  init() {
+    this.updateDisplay(this.config.startValue);
+    this.setupIntersectionObserver();
+  }
+  setupIntersectionObserver() {
+    if (typeof window === "undefined" || typeof window.IntersectionObserver === "undefined") {
+      if (this.config.enabled) {
+        this.start();
+      }
+      return;
+    }
+    this.intersectionObserver = new IntersectionObserver(
+      (entries) => {
+        var _a;
+        for (const entry of entries) {
+          if (entry.target !== this.container) continue;
+          if (entry.isIntersecting) {
+            if (!this.hasTriggered && this.config.enabled) {
+              this.hasTriggered = true;
+              this.start();
+            }
+            if (this.config.triggerOnce) {
+              (_a = this.intersectionObserver) == null ? void 0 : _a.unobserve(this.container);
+            }
+          } else {
+            if (!this.config.triggerOnce) {
+              const rect = entry.boundingClientRect;
+              const viewportHeight = window.innerHeight;
+              const viewportWidth = window.innerWidth;
+              const isCompletelyOutOfViewport = rect.bottom <= 0 || rect.top >= viewportHeight || rect.right <= 0 || rect.left >= viewportWidth;
+              if (isCompletelyOutOfViewport && this.isRunning) {
+                this.reset();
+              }
+            }
+          }
+        }
+      },
+      {
+        threshold: this.config.threshold,
+        rootMargin: this.config.rootMargin
+      }
+    );
+    this.intersectionObserver.observe(this.container);
+  }
+  start() {
+    if (this.isRunning) return;
+    if (!this.config.enabled) return;
+    this.isRunning = true;
+    this.startTime = null;
+    this.currentValue = this.config.startValue;
+    this.updateDisplay(this.currentValue);
+    const animate = (currentTime) => {
+      if (this.startTime === null) {
+        this.startTime = currentTime;
+      }
+      const elapsed = currentTime - this.startTime;
+      const progress = Math.min(elapsed / this.config.duration, 1);
+      const easedProgress = this.config.easing(progress);
+      this.currentValue = Math.floor(
+        this.config.startValue + (this.config.targetValue - this.config.startValue) * easedProgress
+      );
+      this.updateDisplay(this.currentValue);
+      if (this.config.onUpdate) {
+        this.config.onUpdate(this.currentValue);
+      }
+      if (progress < 1) {
+        this.animationFrameId = requestAnimationFrame(animate);
+      } else {
+        this.currentValue = this.config.targetValue;
+        this.updateDisplay(this.currentValue);
+        this.isRunning = false;
+        if (this.config.onComplete) {
+          this.config.onComplete();
+        }
+      }
+    };
+    this.animationFrameId = requestAnimationFrame(animate);
+  }
+  stop() {
+    this.isRunning = false;
+    if (this.animationFrameId !== null) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = null;
+    }
+  }
+  reset() {
+    this.stop();
+    this.currentValue = this.config.startValue;
+    this.updateDisplay(this.currentValue);
+    this.hasTriggered = false;
+    this.startTime = null;
+  }
+  updateDisplay(value) {
+    this.container.textContent = this.formatNumber(value);
+  }
+  formatNumber(value) {
+    return Math.floor(value).toLocaleString();
+  }
+  // 설정 업데이트
+  updateConfig(newConfig) {
+    const wasRunning = this.isRunning;
+    this.stop();
+    this.config = {
+      ...this.config,
+      ...newConfig,
+      onUpdate: newConfig.onUpdate !== void 0 ? newConfig.onUpdate : this.config.onUpdate,
+      onComplete: newConfig.onComplete !== void 0 ? newConfig.onComplete : this.config.onComplete
+    };
+    if (newConfig.targetValue !== void 0) {
+      this.reset();
+      if (wasRunning && this.config.enabled) {
+        this.start();
+      }
+    } else {
+      if (wasRunning && this.config.enabled) {
+        this.start();
+      }
+    }
+  }
+  // 현재 값 가져오기
+  getValue() {
+    return this.currentValue;
+  }
+  // 파괴 및 정리
+  destroy() {
+    this.stop();
+    if (this.intersectionObserver) {
+      this.intersectionObserver.disconnect();
+      this.intersectionObserver = null;
+    }
+  }
+}
+function create_fragment(ctx) {
+  let div;
+  return {
+    c() {
+      div = element("div");
+      attr(
+        div,
+        "class",
+        /*className*/
+        ctx[0]
+      );
+      attr(
+        div,
+        "style",
+        /*style*/
+        ctx[1]
+      );
+    },
+    m(target, anchor) {
+      insert(target, div, anchor);
+      ctx[18](div);
+    },
+    p(ctx2, [dirty]) {
+      if (dirty & /*className*/
+      1) {
+        attr(
+          div,
+          "class",
+          /*className*/
+          ctx2[0]
+        );
+      }
+      if (dirty & /*style*/
+      2) {
+        attr(
+          div,
+          "style",
+          /*style*/
+          ctx2[1]
+        );
+      }
+    },
+    i: noop,
+    o: noop,
+    d(detaching) {
+      if (detaching) {
+        detach(div);
+      }
+      ctx[18](null);
+    }
+  };
+}
+function instance_1($$self, $$props, $$invalidate) {
+  let { targetValue = 0 } = $$props;
+  let { duration = 2e3 } = $$props;
+  let { startValue = 0 } = $$props;
+  let { enabled = true } = $$props;
+  let { easing = (t) => t } = $$props;
+  let { threshold = 0.2 } = $$props;
+  let { rootMargin = "0px 0px -100px 0px" } = $$props;
+  let { triggerOnce = false } = $$props;
+  let { className = "" } = $$props;
+  let { style = {} } = $$props;
+  const dispatch = createEventDispatcher();
+  let container;
+  let instance = null;
+  onMount(() => {
+    if (!container) return;
+    const options = {
+      targetValue,
+      duration,
+      startValue,
+      enabled,
+      easing,
+      threshold,
+      rootMargin,
+      triggerOnce,
+      onUpdate: (value) => {
+        dispatch("update", value);
+      },
+      onComplete: () => {
+        dispatch("complete");
+      }
+    };
+    $$invalidate(17, instance = new Count(container, options));
+  });
+  onDestroy(() => {
+    if (instance) {
+      instance.destroy();
+      $$invalidate(17, instance = null);
+    }
+  });
+  function start() {
+    if (instance) {
+      instance.start();
+    }
+  }
+  function stop() {
+    if (instance) {
+      instance.stop();
+    }
+  }
+  function reset() {
+    if (instance) {
+      instance.reset();
+    }
+  }
+  function getValue() {
+    if (instance) {
+      return instance.getValue();
+    }
+    return 0;
+  }
+  function updateConfig(config) {
+    if (instance) {
+      instance.updateConfig(config);
+    }
+  }
+  function destroy() {
+    if (instance) {
+      instance.destroy();
+      $$invalidate(17, instance = null);
+    }
+  }
+  function div_binding($$value) {
+    binding_callbacks[$$value ? "unshift" : "push"](() => {
+      container = $$value;
+      $$invalidate(2, container);
+    });
+  }
+  $$self.$$set = ($$props2) => {
+    if ("targetValue" in $$props2) $$invalidate(3, targetValue = $$props2.targetValue);
+    if ("duration" in $$props2) $$invalidate(4, duration = $$props2.duration);
+    if ("startValue" in $$props2) $$invalidate(5, startValue = $$props2.startValue);
+    if ("enabled" in $$props2) $$invalidate(6, enabled = $$props2.enabled);
+    if ("easing" in $$props2) $$invalidate(7, easing = $$props2.easing);
+    if ("threshold" in $$props2) $$invalidate(8, threshold = $$props2.threshold);
+    if ("rootMargin" in $$props2) $$invalidate(9, rootMargin = $$props2.rootMargin);
+    if ("triggerOnce" in $$props2) $$invalidate(10, triggerOnce = $$props2.triggerOnce);
+    if ("className" in $$props2) $$invalidate(0, className = $$props2.className);
+    if ("style" in $$props2) $$invalidate(1, style = $$props2.style);
+  };
+  $$self.$$.update = () => {
+    if ($$self.$$.dirty & /*instance, targetValue, duration, startValue, enabled, easing, threshold, rootMargin, triggerOnce*/
+    133112) {
+      {
+        if (instance) {
+          instance.updateConfig({
+            targetValue,
+            duration,
+            startValue,
+            enabled,
+            easing,
+            threshold,
+            rootMargin,
+            triggerOnce,
+            onUpdate: (value) => {
+              dispatch("update", value);
+            },
+            onComplete: () => {
+              dispatch("complete");
+            }
+          });
+        }
+      }
+    }
+  };
+  return [
+    className,
+    style,
+    container,
+    targetValue,
+    duration,
+    startValue,
+    enabled,
+    easing,
+    threshold,
+    rootMargin,
+    triggerOnce,
+    start,
+    stop,
+    reset,
+    getValue,
+    updateConfig,
+    destroy,
+    instance,
+    div_binding
+  ];
+}
+class Count_1 extends SvelteComponent {
+  constructor(options) {
+    super();
+    init(this, options, instance_1, create_fragment, safe_not_equal, {
+      targetValue: 3,
+      duration: 4,
+      startValue: 5,
+      enabled: 6,
+      easing: 7,
+      threshold: 8,
+      rootMargin: 9,
+      triggerOnce: 10,
+      className: 0,
+      style: 1,
+      start: 11,
+      stop: 12,
+      reset: 13,
+      getValue: 14,
+      updateConfig: 15,
+      destroy: 16
+    });
+  }
+  get start() {
+    return this.$$.ctx[11];
+  }
+  get stop() {
+    return this.$$.ctx[12];
+  }
+  get reset() {
+    return this.$$.ctx[13];
+  }
+  get getValue() {
+    return this.$$.ctx[14];
+  }
+  get updateConfig() {
+    return this.$$.ctx[15];
+  }
+  get destroy() {
+    return this.$$.ctx[16];
+  }
+}
+export {
+  Count_1 as default
+};