@stacksjs/calendar-api 0.61.0

package/README.md

@@ -0,0 +1,60 @@
+# Stacks Calendar
+
+Stacks Calendar is a framework that allows you to easily interact with calendar APIs.
+
+## ☘️ Features
+
+- 📅 Calendar APIs
+
+## 🤖 Usage
+
+```bash
+bun install @stacksjs/calendar
+```
+
+You may now use it in your project:
+
+```ts
+import * as calendar from '@stacksjs/calendar'
+
+// ...
+```
+
+Learn more in the docs.
+
+## 🧪 Testing
+
+```bash
+bun test
+```
+
+## 📈 Changelog
+
+Please see our [releases](https://github.com/stacksjs/stacks/releases) page for more information on what has changed recently.
+
+## 🚜 Contributing
+
+Please review the [Contributing Guide](https://github.com/stacksjs/contributing) for details.
+
+## 🏝 Community
+
+For help, discussion about best practices, or any other conversation that would benefit from being searchable:
+
+[Discussions on GitHub](https://github.com/stacksjs/stacks/discussions)
+
+For casual chit-chat with others using this package:
+
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
+
+## 🙏🏼 Credits
+
+Many thanks to the following core technologies & people who have contributed to this package:
+
+- [Chris Breuer](https://github.com/chrisbbreuer)
+- [All Contributors](../../contributors)
+
+## 📄 License
+
+The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
+
+Made with 💙

package/dist/index.js

@@ -0,0 +1,642 @@
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../../../node_modules/crypto-js/core.js
+var require_core = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory();
+    } else if (typeof define === "function" && define.amd) {
+      define([], factory);
+    } else {
+      root.CryptoJS = factory();
+    }
+  })(exports, function() {
+    var CryptoJS = CryptoJS || function(Math2, undefined2) {
+      var crypto;
+      if (typeof window !== "undefined" && window.crypto) {
+        crypto = window.crypto;
+      }
+      if (typeof self !== "undefined" && self.crypto) {
+        crypto = self.crypto;
+      }
+      if (typeof globalThis !== "undefined" && globalThis.crypto) {
+        crypto = globalThis.crypto;
+      }
+      if (!crypto && typeof window !== "undefined" && window.msCrypto) {
+        crypto = window.msCrypto;
+      }
+      if (!crypto && typeof global !== "undefined" && global.crypto) {
+        crypto = global.crypto;
+      }
+      if (!crypto && typeof import.meta.require === "function") {
+        try {
+          crypto = import.meta.require("crypto");
+        } catch (err) {
+        }
+      }
+      var cryptoSecureRandomInt = function() {
+        if (crypto) {
+          if (typeof crypto.getRandomValues === "function") {
+            try {
+              return crypto.getRandomValues(new Uint32Array(1))[0];
+            } catch (err) {
+            }
+          }
+          if (typeof crypto.randomBytes === "function") {
+            try {
+              return crypto.randomBytes(4).readInt32LE();
+            } catch (err) {
+            }
+          }
+        }
+        throw new Error("Native crypto module could not be used to get secure random number.");
+      };
+      var create = Object.create || function() {
+        function F() {
+        }
+        return function(obj) {
+          var subtype;
+          F.prototype = obj;
+          subtype = new F;
+          F.prototype = null;
+          return subtype;
+        };
+      }();
+      var C = {};
+      var C_lib = C.lib = {};
+      var Base = C_lib.Base = function() {
+        return {
+          extend: function(overrides) {
+            var subtype = create(this);
+            if (overrides) {
+              subtype.mixIn(overrides);
+            }
+            if (!subtype.hasOwnProperty("init") || this.init === subtype.init) {
+              subtype.init = function() {
+                subtype.$super.init.apply(this, arguments);
+              };
+            }
+            subtype.init.prototype = subtype;
+            subtype.$super = this;
+            return subtype;
+          },
+          create: function() {
+            var instance = this.extend();
+            instance.init.apply(instance, arguments);
+            return instance;
+          },
+          init: function() {
+          },
+          mixIn: function(properties) {
+            for (var propertyName in properties) {
+              if (properties.hasOwnProperty(propertyName)) {
+                this[propertyName] = properties[propertyName];
+              }
+            }
+            if (properties.hasOwnProperty("toString")) {
+              this.toString = properties.toString;
+            }
+          },
+          clone: function() {
+            return this.init.prototype.extend(this);
+          }
+        };
+      }();
+      var WordArray = C_lib.WordArray = Base.extend({
+        init: function(words, sigBytes) {
+          words = this.words = words || [];
+          if (sigBytes != undefined2) {
+            this.sigBytes = sigBytes;
+          } else {
+            this.sigBytes = words.length * 4;
+          }
+        },
+        toString: function(encoder) {
+          return (encoder || Hex).stringify(this);
+        },
+        concat: function(wordArray) {
+          var thisWords = this.words;
+          var thatWords = wordArray.words;
+          var thisSigBytes = this.sigBytes;
+          var thatSigBytes = wordArray.sigBytes;
+          this.clamp();
+          if (thisSigBytes % 4) {
+            for (var i = 0;i < thatSigBytes; i++) {
+              var thatByte = thatWords[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+              thisWords[thisSigBytes + i >>> 2] |= thatByte << 24 - (thisSigBytes + i) % 4 * 8;
+            }
+          } else {
+            for (var j = 0;j < thatSigBytes; j += 4) {
+              thisWords[thisSigBytes + j >>> 2] = thatWords[j >>> 2];
+            }
+          }
+          this.sigBytes += thatSigBytes;
+          return this;
+        },
+        clamp: function() {
+          var words = this.words;
+          var sigBytes = this.sigBytes;
+          words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
+          words.length = Math2.ceil(sigBytes / 4);
+        },
+        clone: function() {
+          var clone = Base.clone.call(this);
+          clone.words = this.words.slice(0);
+          return clone;
+        },
+        random: function(nBytes) {
+          var words = [];
+          for (var i = 0;i < nBytes; i += 4) {
+            words.push(cryptoSecureRandomInt());
+          }
+          return new WordArray.init(words, nBytes);
+        }
+      });
+      var C_enc = C.enc = {};
+      var Hex = C_enc.Hex = {
+        stringify: function(wordArray) {
+          var words = wordArray.words;
+          var sigBytes = wordArray.sigBytes;
+          var hexChars = [];
+          for (var i = 0;i < sigBytes; i++) {
+            var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+            hexChars.push((bite >>> 4).toString(16));
+            hexChars.push((bite & 15).toString(16));
+          }
+          return hexChars.join("");
+        },
+        parse: function(hexStr) {
+          var hexStrLength = hexStr.length;
+          var words = [];
+          for (var i = 0;i < hexStrLength; i += 2) {
+            words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4;
+          }
+          return new WordArray.init(words, hexStrLength / 2);
+        }
+      };
+      var Latin1 = C_enc.Latin1 = {
+        stringify: function(wordArray) {
+          var words = wordArray.words;
+          var sigBytes = wordArray.sigBytes;
+          var latin1Chars = [];
+          for (var i = 0;i < sigBytes; i++) {
+            var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+            latin1Chars.push(String.fromCharCode(bite));
+          }
+          return latin1Chars.join("");
+        },
+        parse: function(latin1Str) {
+          var latin1StrLength = latin1Str.length;
+          var words = [];
+          for (var i = 0;i < latin1StrLength; i++) {
+            words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+          }
+          return new WordArray.init(words, latin1StrLength);
+        }
+      };
+      var Utf8 = C_enc.Utf8 = {
+        stringify: function(wordArray) {
+          try {
+            return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+          } catch (e) {
+            throw new Error("Malformed UTF-8 data");
+          }
+        },
+        parse: function(utf8Str) {
+          return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+        }
+      };
+      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+        reset: function() {
+          this._data = new WordArray.init;
+          this._nDataBytes = 0;
+        },
+        _append: function(data) {
+          if (typeof data == "string") {
+            data = Utf8.parse(data);
+          }
+          this._data.concat(data);
+          this._nDataBytes += data.sigBytes;
+        },
+        _process: function(doFlush) {
+          var processedWords;
+          var data = this._data;
+          var dataWords = data.words;
+          var dataSigBytes = data.sigBytes;
+          var blockSize = this.blockSize;
+          var blockSizeBytes = blockSize * 4;
+          var nBlocksReady = dataSigBytes / blockSizeBytes;
+          if (doFlush) {
+            nBlocksReady = Math2.ceil(nBlocksReady);
+          } else {
+            nBlocksReady = Math2.max((nBlocksReady | 0) - this._minBufferSize, 0);
+          }
+          var nWordsReady = nBlocksReady * blockSize;
+          var nBytesReady = Math2.min(nWordsReady * 4, dataSigBytes);
+          if (nWordsReady) {
+            for (var offset = 0;offset < nWordsReady; offset += blockSize) {
+              this._doProcessBlock(dataWords, offset);
+            }
+            processedWords = dataWords.splice(0, nWordsReady);
+            data.sigBytes -= nBytesReady;
+          }
+          return new WordArray.init(processedWords, nBytesReady);
+        },
+        clone: function() {
+          var clone = Base.clone.call(this);
+          clone._data = this._data.clone();
+          return clone;
+        },
+        _minBufferSize: 0
+      });
+      var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+        cfg: Base.extend(),
+        init: function(cfg) {
+          this.cfg = this.cfg.extend(cfg);
+          this.reset();
+        },
+        reset: function() {
+          BufferedBlockAlgorithm.reset.call(this);
+          this._doReset();
+        },
+        update: function(messageUpdate) {
+          this._append(messageUpdate);
+          this._process();
+          return this;
+        },
+        finalize: function(messageUpdate) {
+          if (messageUpdate) {
+            this._append(messageUpdate);
+          }
+          var hash = this._doFinalize();
+          return hash;
+        },
+        blockSize: 512 / 32,
+        _createHelper: function(hasher) {
+          return function(message, cfg) {
+            return new hasher.init(cfg).finalize(message);
+          };
+        },
+        _createHmacHelper: function(hasher) {
+          return function(message, key) {
+            return new C_algo.HMAC.init(hasher, key).finalize(message);
+          };
+        }
+      });
+      var C_algo = C.algo = {};
+      return C;
+    }(Math);
+    return CryptoJS;
+  });
+});
+
+// ../../../../node_modules/crypto-js/md5.js
+var require_md5 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function(Math2) {
+      var C = CryptoJS;
+      var C_lib = C.lib;
+      var WordArray = C_lib.WordArray;
+      var Hasher = C_lib.Hasher;
+      var C_algo = C.algo;
+      var T = [];
+      (function() {
+        for (var i = 0;i < 64; i++) {
+          T[i] = Math2.abs(Math2.sin(i + 1)) * 4294967296 | 0;
+        }
+      })();
+      var MD5 = C_algo.MD5 = Hasher.extend({
+        _doReset: function() {
+          this._hash = new WordArray.init([
+            1732584193,
+            4023233417,
+            2562383102,
+            271733878
+          ]);
+        },
+        _doProcessBlock: function(M, offset) {
+          for (var i = 0;i < 16; i++) {
+            var offset_i = offset + i;
+            var M_offset_i = M[offset_i];
+            M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
+          }
+          var H = this._hash.words;
+          var M_offset_0 = M[offset + 0];
+          var M_offset_1 = M[offset + 1];
+          var M_offset_2 = M[offset + 2];
+          var M_offset_3 = M[offset + 3];
+          var M_offset_4 = M[offset + 4];
+          var M_offset_5 = M[offset + 5];
+          var M_offset_6 = M[offset + 6];
+          var M_offset_7 = M[offset + 7];
+          var M_offset_8 = M[offset + 8];
+          var M_offset_9 = M[offset + 9];
+          var M_offset_10 = M[offset + 10];
+          var M_offset_11 = M[offset + 11];
+          var M_offset_12 = M[offset + 12];
+          var M_offset_13 = M[offset + 13];
+          var M_offset_14 = M[offset + 14];
+          var M_offset_15 = M[offset + 15];
+          var a = H[0];
+          var b = H[1];
+          var c = H[2];
+          var d = H[3];
+          a = FF(a, b, c, d, M_offset_0, 7, T[0]);
+          d = FF(d, a, b, c, M_offset_1, 12, T[1]);
+          c = FF(c, d, a, b, M_offset_2, 17, T[2]);
+          b = FF(b, c, d, a, M_offset_3, 22, T[3]);
+          a = FF(a, b, c, d, M_offset_4, 7, T[4]);
+          d = FF(d, a, b, c, M_offset_5, 12, T[5]);
+          c = FF(c, d, a, b, M_offset_6, 17, T[6]);
+          b = FF(b, c, d, a, M_offset_7, 22, T[7]);
+          a = FF(a, b, c, d, M_offset_8, 7, T[8]);
+          d = FF(d, a, b, c, M_offset_9, 12, T[9]);
+          c = FF(c, d, a, b, M_offset_10, 17, T[10]);
+          b = FF(b, c, d, a, M_offset_11, 22, T[11]);
+          a = FF(a, b, c, d, M_offset_12, 7, T[12]);
+          d = FF(d, a, b, c, M_offset_13, 12, T[13]);
+          c = FF(c, d, a, b, M_offset_14, 17, T[14]);
+          b = FF(b, c, d, a, M_offset_15, 22, T[15]);
+          a = GG(a, b, c, d, M_offset_1, 5, T[16]);
+          d = GG(d, a, b, c, M_offset_6, 9, T[17]);
+          c = GG(c, d, a, b, M_offset_11, 14, T[18]);
+          b = GG(b, c, d, a, M_offset_0, 20, T[19]);
+          a = GG(a, b, c, d, M_offset_5, 5, T[20]);
+          d = GG(d, a, b, c, M_offset_10, 9, T[21]);
+          c = GG(c, d, a, b, M_offset_15, 14, T[22]);
+          b = GG(b, c, d, a, M_offset_4, 20, T[23]);
+          a = GG(a, b, c, d, M_offset_9, 5, T[24]);
+          d = GG(d, a, b, c, M_offset_14, 9, T[25]);
+          c = GG(c, d, a, b, M_offset_3, 14, T[26]);
+          b = GG(b, c, d, a, M_offset_8, 20, T[27]);
+          a = GG(a, b, c, d, M_offset_13, 5, T[28]);
+          d = GG(d, a, b, c, M_offset_2, 9, T[29]);
+          c = GG(c, d, a, b, M_offset_7, 14, T[30]);
+          b = GG(b, c, d, a, M_offset_12, 20, T[31]);
+          a = HH(a, b, c, d, M_offset_5, 4, T[32]);
+          d = HH(d, a, b, c, M_offset_8, 11, T[33]);
+          c = HH(c, d, a, b, M_offset_11, 16, T[34]);
+          b = HH(b, c, d, a, M_offset_14, 23, T[35]);
+          a = HH(a, b, c, d, M_offset_1, 4, T[36]);
+          d = HH(d, a, b, c, M_offset_4, 11, T[37]);
+          c = HH(c, d, a, b, M_offset_7, 16, T[38]);
+          b = HH(b, c, d, a, M_offset_10, 23, T[39]);
+          a = HH(a, b, c, d, M_offset_13, 4, T[40]);
+          d = HH(d, a, b, c, M_offset_0, 11, T[41]);
+          c = HH(c, d, a, b, M_offset_3, 16, T[42]);
+          b = HH(b, c, d, a, M_offset_6, 23, T[43]);
+          a = HH(a, b, c, d, M_offset_9, 4, T[44]);
+          d = HH(d, a, b, c, M_offset_12, 11, T[45]);
+          c = HH(c, d, a, b, M_offset_15, 16, T[46]);
+          b = HH(b, c, d, a, M_offset_2, 23, T[47]);
+          a = II(a, b, c, d, M_offset_0, 6, T[48]);
+          d = II(d, a, b, c, M_offset_7, 10, T[49]);
+          c = II(c, d, a, b, M_offset_14, 15, T[50]);
+          b = II(b, c, d, a, M_offset_5, 21, T[51]);
+          a = II(a, b, c, d, M_offset_12, 6, T[52]);
+          d = II(d, a, b, c, M_offset_3, 10, T[53]);
+          c = II(c, d, a, b, M_offset_10, 15, T[54]);
+          b = II(b, c, d, a, M_offset_1, 21, T[55]);
+          a = II(a, b, c, d, M_offset_8, 6, T[56]);
+          d = II(d, a, b, c, M_offset_15, 10, T[57]);
+          c = II(c, d, a, b, M_offset_6, 15, T[58]);
+          b = II(b, c, d, a, M_offset_13, 21, T[59]);
+          a = II(a, b, c, d, M_offset_4, 6, T[60]);
+          d = II(d, a, b, c, M_offset_11, 10, T[61]);
+          c = II(c, d, a, b, M_offset_2, 15, T[62]);
+          b = II(b, c, d, a, M_offset_9, 21, T[63]);
+          H[0] = H[0] + a | 0;
+          H[1] = H[1] + b | 0;
+          H[2] = H[2] + c | 0;
+          H[3] = H[3] + d | 0;
+        },
+        _doFinalize: function() {
+          var data = this._data;
+          var dataWords = data.words;
+          var nBitsTotal = this._nDataBytes * 8;
+          var nBitsLeft = data.sigBytes * 8;
+          dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+          var nBitsTotalH = Math2.floor(nBitsTotal / 4294967296);
+          var nBitsTotalL = nBitsTotal;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
+          data.sigBytes = (dataWords.length + 1) * 4;
+          this._process();
+          var hash = this._hash;
+          var H = hash.words;
+          for (var i = 0;i < 4; i++) {
+            var H_i = H[i];
+            H[i] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
+          }
+          return hash;
+        },
+        clone: function() {
+          var clone = Hasher.clone.call(this);
+          clone._hash = this._hash.clone();
+          return clone;
+        }
+      });
+      function FF(a, b, c, d, x, s, t) {
+        var n = a + (b & c | ~b & d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function GG(a, b, c, d, x, s, t) {
+        var n = a + (b & d | c & ~d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function HH(a, b, c, d, x, s, t) {
+        var n = a + (b ^ c ^ d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function II(a, b, c, d, x, s, t) {
+        var n = a + (c ^ (b | ~d)) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      C.MD5 = Hasher._createHelper(MD5);
+      C.HmacMD5 = Hasher._createHmacHelper(MD5);
+    })(Math);
+    return CryptoJS.MD5;
+  });
+});
+
+// src/generators/google.ts
+var generateGoogle = function(link) {
+  let url = "https://calendar.google.com/calendar/render?action=TEMPLATE";
+  const utcStartDateTime = convertTZ(link.from, "UTC");
+  const utcEndDateTime = convertTZ(link.to, "UTC");
+  const dateTimeFormat = link.allDay ? dateFormat : timeFormat;
+  url = `${url}&dates=${useDateFormat(utcStartDateTime, dateTimeFormat).value}/${useDateFormat(utcEndDateTime, dateTimeFormat).value}`;
+  if (link.timezone)
+    url = `${url}&ctz=${link.timezone}`;
+  url = `${url}&text=${encodeURIComponent(link.title)}`;
+  if (link.description)
+    url = `${url}&details=${encodeURIComponent(link.description)}`;
+  if (link.address)
+    url = `${url}&location=${encodeURIComponent(link.address)}`;
+  return url;
+};
+var convertTZ = function(date, tzString) {
+  return new Date((typeof date === "string" ? new Date(date) : date).toLocaleString("en-US", { timeZone: tzString }));
+};
+var dateFormat = "YYYYMMDD";
+var timeFormat = "YYYYMMDDThhmmss";
+var google_default = generateGoogle;
+
+// src/generators/ics.ts
+var md5 = __toESM(require_md5(), 1);
+var generateIcs = function(link) {
+  const uid = `UID:${generateEventUid(link)}`;
+  const summary = `SUMMARY:${link.title}`;
+  const url = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:Spatie calendar-links",
+    "BEGIN:VEVENT",
+    uid,
+    summary
+  ];
+  const timezone = link.timezone || "PST";
+  const formatTime = `${timezone}:${timeFormat2}`;
+  const dateTimeFormat = link.allDay ? dateFormat2 : formatTime;
+  if (link.allDay) {
+    url.push(`DTSTAMP;TZID=${useDateFormat(link.from, dateTimeFormat).value}`);
+    url.push(`DTSTART:${useDateFormat(link.from, dateTimeFormat).value}`);
+    url.push(`DURATION:P${useMax(1, dateDiffInDays(link.from, link.to)).value}D`);
+  } else {
+    url.push(`DTSTAMP;TZID=${useDateFormat(link.from, dateTimeFormat).value}`);
+    url.push(`DTSTART;TZID=${useDateFormat(link.from, dateTimeFormat).value}`);
+    url.push(`DTEND;TZID=${useDateFormat(link.to, dateTimeFormat).value}`);
+  }
+  if (link.description)
+    url.push(`X-ALT-DESC;FMTTYPE=text/html:${link.description}`);
+  if (link.address)
+    url.push(`LOCATION:${link.address}`);
+  url.push("END:VEVENT");
+  url.push("END:VCALENDAR");
+  return buildLink(url);
+};
+var buildLink = function(propertiesAndComponents) {
+  return `data:text/calendar;charset=utf8;base64,${btoa(propertiesAndComponents.join("\r\n"))}`;
+};
+var dateDiffInDays = function(from, to) {
+  const _MS_PER_DAY = 86400000;
+  const utc1 = Date.UTC(from.getFullYear(), from.getMonth(), from.getDate());
+  const utc2 = Date.UTC(to.getFullYear(), to.getMonth(), to.getDate());
+  return Math.floor((utc2 - utc1) / _MS_PER_DAY);
+};
+var generateEventUid = function(link) {
+  const from = useDateFormat(link.from, atomicFormat).value;
+  const to = useDateFormat(link.to, atomicFormat).value;
+  return md5.default(`${from}${to}${link.title}`).toString();
+};
+var dateFormat2 = "YYYYMMDD";
+var timeFormat2 = "YYYYMMDDThhmmss";
+var atomicFormat = "YYYY-MM-DDThh:mm:ss+00:00";
+var ics_default = generateIcs;
+
+// src/generators/weboutlook.ts
+var generateOutlook = function(link) {
+  let url = BASE_URL;
+  const utcStartDateTime = convertTZ2(link.from, "UTC");
+  const utcEndDateTime = convertTZ2(link.to, "UTC");
+  const dateTimeFormat = link.allDay ? dateFormat3 : timeFormat3;
+  url = link.allDay ? `${url}&startdt=${useDateFormat(utcStartDateTime, dateTimeFormat).value}` : `${url}&startdt=${useDateFormat(utcStartDateTime, dateTimeFormat).value}Z`;
+  url = link.allDay ? `${url}&enddt=${useDateFormat(utcEndDateTime, dateTimeFormat).value}` : `${url}&enddt=${useDateFormat(utcEndDateTime, dateTimeFormat).value}Z`;
+  if (link.allDay)
+    url = `${url}&allday=true`;
+  url = `${url}&subject=${encodeURIComponent(link.title)}`;
+  if (link.description)
+    url = `${url}&body=${encodeURIComponent(link.description)}`;
+  if (link.address)
+    url = `${url}&location=${encodeURIComponent(link.address)}`;
+  return url;
+};
+var convertTZ2 = function(date, tzString) {
+  return new Date((typeof date === "string" ? new Date(date) : date).toLocaleString("en-US", { timeZone: tzString }));
+};
+var dateFormat3 = "YYYY-MM-DD";
+var timeFormat3 = "YYYY-MM-DDThh:mm:ss";
+var BASE_URL = "https://outlook.live.com/calendar/deeplink/compose?path=/calendar/action/compose&rru=addevent";
+var weboutlook_default = generateOutlook;
+
+// src/generators/yahoo.ts
+var generateYahoo = function(link) {
+  let url = "https://calendar.yahoo.com/?v=60&view=d&type=20";
+  const utcStartDateTime = convertTZ3(link.from, "UTC");
+  const utcEndDateTime = convertTZ3(link.to, "UTC");
+  const dateTimeFormat = link.allDay ? dateFormat4 : timeFormat4;
+  if (link.allDay) {
+    url = `${url}&ST=${useDateFormat(link.from, dateTimeFormat).value}`;
+    url = `${url}&DUR=allday`;
+    url = `${url}&ET=${useDateFormat(link.to, dateTimeFormat).value}`;
+  } else {
+    url = `${url}&ST=${useDateFormat(utcStartDateTime, dateTimeFormat).value}Z`;
+    url = `${url}&ET=${useDateFormat(utcEndDateTime, dateTimeFormat).value}Z`;
+  }
+  url = `${url}&TITLE=${encodeURIComponent(link.title)}`;
+  if (link.description)
+    url = `${url}&DESC=${encodeURIComponent(link.description)}`;
+  if (link.address)
+    url = `${url}&in_loc=${encodeURIComponent(link.address)}`;
+  return url;
+};
+var convertTZ3 = function(date, tzString) {
+  return new Date((typeof date === "string" ? new Date(date) : date).toLocaleString("en-US", { timeZone: tzString }));
+};
+var dateFormat4 = "YYYYMMDD";
+var timeFormat4 = "YYYYMMDDThhmmss";
+var yahoo_default = generateYahoo;
+
+// src/links.ts
+var exportCalendarGoogle = function() {
+  return google_default(link);
+};
+var exportCalendarIcs = function() {
+  return ics_default(link);
+};
+var exportCalendarOutlook = function() {
+  return weboutlook_default(link);
+};
+var exportCalendarYahoo = function() {
+  return yahoo_default(link);
+};
+var link = {
+  from: new Date("2022-12-12 01:00:00"),
+  to: new Date("2022-12-12 05:00:00"),
+  allDay: false,
+  address: "Playa Vista, Los Angeles, CA, USA",
+  title: "test appointment",
+  description: "test description",
+  timezone: "EDT"
+};
+export {
+  exportCalendarYahoo,
+  exportCalendarOutlook,
+  exportCalendarIcs,
+  exportCalendarGoogle
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@stacksjs/calendar-api",
+  "type": "module",
+  "version": "0.61.0",
+  "description": "Easily interact with calendar APIs.",
+  "author": "Chris Breuer",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/chrisbbreuer",
+  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/calendar#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stacksjs/stacks.git",
+    "directory": "./storage/framework/core/calendar"
+  },
+  "bugs": {
+    "url": "https://github.com/stacksjs/stacks/issues"
+  },
+  "keywords": [
+    "calendar",
+    "stacks",
+    "ical",
+    "google calendar",
+    "outlook calendar"
+  ],
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "bun": "./src/*",
+      "import": "./dist/*"
+    }
+  },
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "contributors": [
+    "Chris Breuer <chris@stacksjs.org>"
+  ],
+  "files": [
+    "README.md",
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "bun --bun build.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@stacksjs/development": "latest"
+  }
+}

package/src/generators/google.ts

@@ -0,0 +1,34 @@
+import type { CalendarLink } from '../types'
+
+const dateFormat = 'YYYYMMDD'
+const timeFormat = 'YYYYMMDDThhmmss'
+
+function generateGoogle(link: CalendarLink): string {
+  // 20221020T170000Z/20221020T173000Z
+
+  let url = 'https://calendar.google.com/calendar/render?action=TEMPLATE'
+
+  const utcStartDateTime = convertTZ(link.from, 'UTC') // set timezone to UTC
+  const utcEndDateTime = convertTZ(link.to, 'UTC') // set timezone to UTC
+  const dateTimeFormat = link.allDay ? dateFormat : timeFormat
+
+  url = `${url}&dates=${useDateFormat(utcStartDateTime, dateTimeFormat).value}/${
+    useDateFormat(utcEndDateTime, dateTimeFormat).value
+  }`
+
+  if (link.timezone) url = `${url}&ctz=${link.timezone}`
+
+  url = `${url}&text=${encodeURIComponent(link.title)}`
+
+  if (link.description) url = `${url}&details=${encodeURIComponent(link.description)}`
+
+  if (link.address) url = `${url}&location=${encodeURIComponent(link.address)}`
+
+  return url
+}
+
+function convertTZ(date: Date | string, tzString: string): Date {
+  return new Date((typeof date === 'string' ? new Date(date) : date).toLocaleString('en-US', { timeZone: tzString }))
+}
+
+export default generateGoogle

package/src/generators/ics.ts

@@ -0,0 +1,74 @@
+import md5 from 'crypto-js/md5'
+import type { CalendarLink } from '../types'
+
+const dateFormat = 'YYYYMMDD'
+const timeFormat = 'YYYYMMDDThhmmss'
+
+const atomicFormat = 'YYYY-MM-DDThh:mm:ss+00:00'
+
+function generateIcs(link: CalendarLink): string {
+  const uid = `UID:${generateEventUid(link)}`
+  const summary = `SUMMARY:${link.title}`
+
+  const url = [
+    'BEGIN:VCALENDAR',
+    'VERSION:2.0', // @see https://datatracker.ietf.org/doc/html/rfc5545#section-3.7.4
+    'PRODID:Spatie calendar-links', // @see https://datatracker.ietf.org/doc/html/rfc5545#section-3.7.3
+    'BEGIN:VEVENT',
+    uid,
+    summary,
+  ]
+
+  const timezone = link.timezone || 'PST'
+
+  const formatTime = `${timezone}:${timeFormat}`
+
+  const dateTimeFormat = link.allDay ? dateFormat : formatTime
+
+  if (link.allDay) {
+    url.push(`DTSTAMP;TZID=${useDateFormat(link.from, dateTimeFormat).value}`)
+    url.push(`DTSTART:${useDateFormat(link.from, dateTimeFormat).value}`)
+    url.push(`DURATION:P${useMax(1, dateDiffInDays(link.from, link.to)).value}D`)
+  } else {
+    url.push(`DTSTAMP;TZID=${useDateFormat(link.from, dateTimeFormat).value}`)
+    url.push(`DTSTART;TZID=${useDateFormat(link.from, dateTimeFormat).value}`)
+    url.push(`DTEND;TZID=${useDateFormat(link.to, dateTimeFormat).value}`)
+  }
+
+  if (link.description) url.push(`X-ALT-DESC;FMTTYPE=text/html:${link.description}`)
+
+  if (link.address) url.push(`LOCATION:${link.address}`)
+
+  url.push('END:VEVENT')
+  url.push('END:VCALENDAR')
+
+  return buildLink(url)
+}
+
+function buildLink(propertiesAndComponents: any): string {
+  return `data:text/calendar;charset=utf8;base64,${btoa(propertiesAndComponents.join('\r\n'))}`
+}
+
+// a and b are javascript Date objects
+function dateDiffInDays(from: Date, to: Date): number {
+  const _MS_PER_DAY = 1000 * 60 * 60 * 24
+
+  // Discard the time and time-zone information.
+  const utc1 = Date.UTC(from.getFullYear(), from.getMonth(), from.getDate())
+  const utc2 = Date.UTC(to.getFullYear(), to.getMonth(), to.getDate())
+
+  return Math.floor((utc2 - utc1) / _MS_PER_DAY)
+}
+
+function generateEventUid(link: any): string {
+  const from = useDateFormat(link.from, atomicFormat).value
+  const to = useDateFormat(link.to, atomicFormat).value
+
+  return md5(`${from}${to}${link.title}`).toString()
+}
+
+// function escapeString(field: string): string {
+//   return addcslashes(field, '\r\n,;')
+// }
+
+export default generateIcs

package/src/generators/weboutlook.ts

@@ -0,0 +1,39 @@
+import type { CalendarLink } from '../types'
+
+const dateFormat = 'YYYY-MM-DD'
+const timeFormat = 'YYYY-MM-DDThh:mm:ss'
+
+const BASE_URL = 'https://outlook.live.com/calendar/deeplink/compose?path=/calendar/action/compose&rru=addevent'
+
+function generateOutlook(link: CalendarLink): string {
+  // 20221020T170000Z/20221020T173000Z
+
+  let url = BASE_URL
+
+  const utcStartDateTime = convertTZ(link.from, 'UTC') // set timezone to UTC
+  const utcEndDateTime = convertTZ(link.to, 'UTC') // set timezone to UTC
+  const dateTimeFormat = link.allDay ? dateFormat : timeFormat
+
+  url = link.allDay
+    ? `${url}&startdt=${useDateFormat(utcStartDateTime, dateTimeFormat).value}`
+    : `${url}&startdt=${useDateFormat(utcStartDateTime, dateTimeFormat).value}Z`
+  url = link.allDay
+    ? `${url}&enddt=${useDateFormat(utcEndDateTime, dateTimeFormat).value}`
+    : `${url}&enddt=${useDateFormat(utcEndDateTime, dateTimeFormat).value}Z`
+
+  if (link.allDay) url = `${url}&allday=true`
+
+  url = `${url}&subject=${encodeURIComponent(link.title)}`
+
+  if (link.description) url = `${url}&body=${encodeURIComponent(link.description)}`
+
+  if (link.address) url = `${url}&location=${encodeURIComponent(link.address)}`
+
+  return url
+}
+
+function convertTZ(date: Date | string, tzString: string): Date {
+  return new Date((typeof date === 'string' ? new Date(date) : date).toLocaleString('en-US', { timeZone: tzString }))
+}
+
+export default generateOutlook

package/src/generators/yahoo.ts

@@ -0,0 +1,35 @@
+import type { CalendarLink } from '../types'
+
+const dateFormat = 'YYYYMMDD'
+const timeFormat = 'YYYYMMDDThhmmss'
+
+function generateYahoo(link: CalendarLink): string {
+  let url = 'https://calendar.yahoo.com/?v=60&view=d&type=20'
+
+  const utcStartDateTime = convertTZ(link.from, 'UTC') // set timezone to UTC
+  const utcEndDateTime = convertTZ(link.to, 'UTC') // set timezone to UTC
+  const dateTimeFormat = link.allDay ? dateFormat : timeFormat
+
+  if (link.allDay) {
+    url = `${url}&ST=${useDateFormat(link.from, dateTimeFormat).value}`
+    url = `${url}&DUR=allday`
+    url = `${url}&ET=${useDateFormat(link.to, dateTimeFormat).value}`
+  } else {
+    url = `${url}&ST=${useDateFormat(utcStartDateTime, dateTimeFormat).value}Z`
+    url = `${url}&ET=${useDateFormat(utcEndDateTime, dateTimeFormat).value}Z`
+  }
+
+  url = `${url}&TITLE=${encodeURIComponent(link.title)}`
+
+  if (link.description) url = `${url}&DESC=${encodeURIComponent(link.description)}`
+
+  if (link.address) url = `${url}&in_loc=${encodeURIComponent(link.address)}`
+
+  return url
+}
+
+function convertTZ(date: Date | string, tzString: string): Date {
+  return new Date((typeof date === 'string' ? new Date(date) : date).toLocaleString('en-US', { timeZone: tzString }))
+}
+
+export default generateYahoo

package/src/index.ts

@@ -0,0 +1 @@
+export * from './links'

package/src/links.ts

@@ -0,0 +1,37 @@
+import generateGoogle from './generators/google'
+import generateIcs from './generators/ics'
+import generateOutlook from './generators/weboutlook'
+import generateYahoo from './generators/yahoo'
+import type { CalendarLink } from './types'
+
+const link: CalendarLink = {
+  from: new Date('2022-12-12 01:00:00'),
+  to: new Date('2022-12-12 05:00:00'),
+  allDay: false,
+  address: 'Playa Vista, Los Angeles, CA, USA',
+  title: 'test appointment',
+  description: 'test description',
+  timezone: 'EDT',
+}
+
+// functions that mutate state and trigger updates
+function exportCalendarGoogle(): string {
+  return generateGoogle(link)
+}
+
+// functions that mutate state and trigger updates
+function exportCalendarIcs(): string {
+  return generateIcs(link)
+}
+
+// functions that mutate state and trigger updates
+function exportCalendarOutlook(): string {
+  return generateOutlook(link)
+}
+
+// functions that mutate state and trigger updates
+function exportCalendarYahoo(): string {
+  return generateYahoo(link)
+}
+
+export { exportCalendarIcs, exportCalendarGoogle, exportCalendarOutlook, exportCalendarYahoo }

package/src/types.ts

@@ -0,0 +1,47 @@
+import type { Ref } from 'vue'
+
+export interface CalendarStore {
+  day: number
+  month: Ref<number>
+  year: Ref<number>
+  currentMonthYear: Ref<string>
+  currentMonthDayYear: Ref<string>
+  datesOfThePastMonth: Ref<number[]>
+  datesOfTheMonth: Ref<number[]>
+  datesOfNextMonth: Ref<number[]>
+  currentWeekView: Ref<number[]>
+  currentWeekViewToday: Ref<number[]>
+}
+
+export interface Time {
+  from: string
+  to: string
+}
+export interface Events {
+  date: string
+  title: string
+  description: string
+  month: number
+  day: number
+  year: number
+  time: Time
+}
+
+export interface WeekDates {
+  month: number
+  date: number
+}
+
+export interface TimeTableStyle {
+  time: string
+  gridRow: string
+}
+export interface CalendarLink {
+  from: Date
+  to: Date
+  allDay: Boolean
+  address: string
+  title: string
+  description: string
+  timezone: string
+}