qstd 0.1.0

package/dist/server/index.cjs

@@ -0,0 +1,541 @@
+'use strict';
+
+var dateFns = require('date-fns');
+var fs = require('fs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/list.ts
+var list_exports = {};
+__export(list_exports, {
+  chunk: () => chunk,
+  create: () => create,
+  partition: () => partition,
+  zipWith: () => zipWith
+});
+function zipWith(fn, ...arrays) {
+  if (arrays.length === 0) return [];
+  const minLength = Math.min(...arrays.map((arr) => arr.length));
+  const result = [];
+  for (let i = 0; i < minLength; i++) {
+    const args = arrays.map((arr) => arr[i]);
+    result.push(fn(...args));
+  }
+  return result;
+}
+var create = (size, fn) => fn ? Array(size).fill(null).map(fn) : Array(size).fill(null);
+var partition = (xs, predicate) => xs.reduce(
+  ([truthList, falseList], x) => {
+    const passes = predicate(x);
+    if (passes) truthList.push(x);
+    else falseList.push(x);
+    return [truthList, falseList];
+  },
+  [[], []]
+);
+var chunk = (list, chunkSize) => {
+  const totalChunks = Math.ceil(list.length / chunkSize);
+  return Array.from({ length: totalChunks }, (_, i) => {
+    const start = i * chunkSize;
+    const end = i * chunkSize + chunkSize;
+    return list.slice(start, end);
+  });
+};
+
+// src/shared/dict.ts
+var dict_exports = {};
+__export(dict_exports, {
+  byteSizeOfObj: () => byteSizeOfObj,
+  exists: () => exists,
+  filter: () => filter,
+  isEmpty: () => isEmpty,
+  omit: () => omit,
+  partition: () => partition2,
+  pick: () => pick,
+  transform: () => transform
+});
+function byteSizeOfObj(o) {
+  const objectList = [];
+  const stack = [o];
+  const bytes = [0];
+  while (stack.length) {
+    const value = stack.pop();
+    if (value == null) bytes[0] += 4;
+    else if (typeof value === "boolean") bytes[0] += 4;
+    else if (typeof value === "string") bytes[0] += value.length * 2;
+    else if (typeof value === "number") bytes[0] += 8;
+    else if (typeof value === "object" && objectList.indexOf(value) === -1) {
+      objectList.push(value);
+      if (typeof value.byteLength === "number") bytes[0] += value.byteLength;
+      else if (value[Symbol.iterator]) {
+        for (const v of value) stack.push(v);
+      } else {
+        Object.keys(value).forEach((k) => {
+          bytes[0] += k.length * 2;
+          stack.push(value[k]);
+        });
+      }
+    }
+  }
+  return bytes[0];
+}
+var filter = (r, predicate) => Object.entries(r).reduce(
+  (store, [key, value]) => predicate(value) ? { ...store, [key]: value } : store,
+  {}
+);
+var transform = (r, transformFn) => Object.entries(r).reduce(
+  (store, [key, value]) => ({
+    ...store,
+    ...transformFn(key, value)
+  }),
+  {}
+);
+var partition2 = (r, predicate) => {
+  const passed = {};
+  const failed = {};
+  for (const key in r) {
+    if (predicate(key)) passed[key] = r[key];
+    else failed[key] = r[key];
+  }
+  return [passed, failed];
+};
+var exists = (obj) => {
+  return obj && typeof obj === "object" && Object.keys(obj).length > 0;
+};
+var isEmpty = (obj) => {
+  return !obj || Object.keys(obj).length === 0 && obj.constructor === Object;
+};
+var pick = (r, paths) => Object.entries(r).reduce(
+  (store, [key, value]) => paths.includes(key) ? { ...store, [key]: value } : store,
+  {}
+);
+var omit = (r, paths) => {
+  if (!r) {
+    throw new Error("[omit] item was not an object");
+  }
+  return Object.entries(r).reduce((store, [key, value]) => {
+    if (paths.includes(key)) {
+      return store;
+    } else {
+      store[key] = value;
+      return store;
+    }
+  }, {});
+};
+
+// src/shared/str.ts
+var str_exports = {};
+__export(str_exports, {
+  concat: () => concat,
+  countChar: () => countChar,
+  countWords: () => countWords,
+  createSentences: () => createSentences,
+  toCase: () => toCase
+});
+var createSentences = (text) => {
+  if (!text) return [];
+  return text?.replace(/([.?!])\s*(?=[A-Z])/g, "$1|").split("|");
+};
+var countWords = (text) => {
+  text = text.trim();
+  if (text.length === 0) {
+    return 0;
+  }
+  const wordPattern = /\w+/g;
+  const matches = text.match(wordPattern);
+  return matches ? matches.length : 0;
+};
+var concat = (xs, delimiter) => {
+  return xs.filter((x) => !!x).join(delimiter);
+};
+var countChar = (str, ch) => {
+  return str.split("").reduce((x, y) => y === ch ? x + 1 : x, 0);
+};
+var toCase = (text, opts) => {
+  switch (opts.to) {
+    case "title":
+      return text.charAt(0).toUpperCase() + text.slice(1);
+    case "snake":
+      return text.replace(
+        /[A-Z]/g,
+        (l, idx) => idx === 0 ? l.toLowerCase() : "_" + l.toLowerCase()
+      );
+    case "kebab": {
+      const lowered = text.toLowerCase().trim();
+      const cleaned = opts.clean ? lowered.replaceAll(/[:,]/g, "") : lowered;
+      return cleaned.replaceAll(/\s+/g, "-");
+    }
+    default:
+      return text;
+  }
+};
+
+// src/shared/int.ts
+var int_exports = {};
+__export(int_exports, {
+  clamp: () => clamp,
+  commaSeparateThousandths: () => commaSeparateThousandths,
+  formatBytes: () => formatBytes
+});
+var clamp = (num2, range) => Math.min(Math.max(num2, range.min), range.max);
+var isNumeric = (x) => {
+  return /^[0-9]+$/.test(x);
+};
+var commaSeparateThousandths = (n) => {
+  if (typeof n === "string" && !isNumeric(n)) {
+    throw new Error(`[comma separate thousandths] Value ${n} must be a number`);
+  }
+  return Number(n).toLocaleString("en-US");
+};
+var formatBytes = (bytes, decimals = 1, binaryUnits = false) => {
+  if (!bytes) return {};
+  if (bytes === 0) return { value: 0, unit: "Bytes" };
+  const unitMultiple = binaryUnits ? 1024 : 1e3;
+  const unitNames = unitMultiple === 1024 ? ["Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"] : ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const unitChanges = Math.floor(Math.log(bytes) / Math.log(unitMultiple));
+  const value = parseFloat(
+    (bytes / Math.pow(unitMultiple, unitChanges)).toFixed(decimals || 0)
+  );
+  const unit = unitNames[unitChanges];
+  return { value, unit, display: `${value}${unit}` };
+};
+
+// src/shared/money.ts
+var money_exports = {};
+__export(money_exports, {
+  convertToCents: () => convertToCents,
+  convertToUsd: () => convertToUsd
+});
+var convertToUsd = (cents, opts = {}) => {
+  if (!cents) return;
+  const dollars = (Number(cents) / 100).toLocaleString("en-US", {
+    style: "currency",
+    currency: "USD"
+  });
+  const showSymbol = opts.symbol ?? true;
+  return showSymbol ? dollars : dollars.slice(1);
+};
+var convertToCents = (dollars) => {
+  const str = dollars.toString().replaceAll(/[\$,]+/g, "");
+  return Number(str) * 100;
+};
+
+// src/shared/time.ts
+var time_exports = {};
+__export(time_exports, {
+  adjustDate: () => adjustDate,
+  formatDate: () => formatDate,
+  formatDateRange: () => formatDateRange,
+  formatDuration: () => formatDuration,
+  formatThreadDateRange: () => formatThreadDateRange,
+  now: () => now,
+  sleep: () => sleep,
+  toMs: () => toMs
+});
+var formatDuration = (ms, options = {}) => {
+  if (ms === null || ms === void 0) return "--:--";
+  const { format: fmt = "clock", showZero = false } = options;
+  const totalSeconds = Math.floor(Math.abs(ms) / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (fmt === "clock") {
+    if (hours > 0) {
+      return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+    }
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+  if (fmt === "full") {
+    const parts2 = [];
+    if (showZero) {
+      const hasHours = hours > 0;
+      const hasMinutes = minutes > 0;
+      const hasSeconds = seconds > 0;
+      if (hasHours || hasMinutes || hasSeconds) {
+        if (hasHours) parts2.push(`${hours} ${hours === 1 ? "hour" : "hours"}`);
+        if (hasHours || hasMinutes)
+          parts2.push(`${minutes} ${minutes === 1 ? "minute" : "minutes"}`);
+        parts2.push(`${seconds} ${seconds === 1 ? "second" : "seconds"}`);
+      } else {
+        parts2.push("0 seconds");
+      }
+    } else {
+      if (hours > 0) parts2.push(`${hours} ${hours === 1 ? "hour" : "hours"}`);
+      if (minutes > 0)
+        parts2.push(`${minutes} ${minutes === 1 ? "minute" : "minutes"}`);
+      if (seconds > 0)
+        parts2.push(`${seconds} ${seconds === 1 ? "second" : "seconds"}`);
+    }
+    return parts2.join(" ") || "0 seconds";
+  }
+  if (fmt === "fractional") {
+    const totalSecondsWithFraction = Math.abs(ms) / 1e3;
+    const totalMinutes = Math.floor(totalSecondsWithFraction / 60);
+    if (totalMinutes === 0) {
+      const fractionalSeconds = totalSecondsWithFraction.toFixed(1);
+      return `${fractionalSeconds}s`;
+    } else {
+      const remainingSeconds = totalSecondsWithFraction % 60;
+      const fractionalSeconds = remainingSeconds.toFixed(1);
+      return `${totalMinutes}m ${fractionalSeconds}s`;
+    }
+  }
+  const parts = [];
+  if (showZero) {
+    const hasHours = hours > 0;
+    const hasMinutes = minutes > 0;
+    const hasSeconds = seconds > 0;
+    if (hasHours || hasMinutes || hasSeconds) {
+      if (hasHours) parts.push(`${hours}h`);
+      if (hasHours || hasMinutes) parts.push(`${minutes}m`);
+      parts.push(`${seconds}s`);
+    } else {
+      parts.push("0s");
+    }
+  } else {
+    if (hours > 0) parts.push(`${hours}h`);
+    if (minutes > 0) parts.push(`${minutes}m`);
+    if (seconds > 0) parts.push(`${seconds}s`);
+  }
+  return parts.join(" ") || "0s";
+};
+var formatDate = (input, options = {}) => {
+  const { style = "medium", pattern, includeTime = false } = options;
+  let date2;
+  if (typeof input === "string") {
+    date2 = new Date(input);
+  } else if (typeof input === "number") {
+    date2 = new Date(input);
+  } else {
+    date2 = input;
+  }
+  if (isNaN(date2.getTime())) {
+    return "Invalid Date";
+  }
+  if (pattern) {
+    return dateFns.format(date2, pattern);
+  }
+  switch (style) {
+    case "iso":
+      return dateFns.formatISO(date2);
+    case "short":
+      return includeTime ? dateFns.format(date2, "M/d/yy h:mm a") : dateFns.format(date2, "M/d/yy");
+    case "medium":
+      return includeTime ? dateFns.format(date2, "MMM d, yyyy h:mm a") : dateFns.format(date2, "MMM d, yyyy");
+    case "long":
+      return includeTime ? dateFns.format(date2, "MMMM d, yyyy 'at' h:mm a") : dateFns.format(date2, "MMMM d, yyyy");
+    case "relative":
+      return dateFns.formatDistanceToNow(date2, { addSuffix: true });
+    case "year":
+      return dateFns.format(date2, "yyyy");
+    default:
+      return includeTime ? dateFns.format(date2, "MMM d, yyyy h:mm a") : dateFns.format(date2, "MMM d, yyyy");
+  }
+};
+var toDate = (input) => typeof input === "string" || typeof input === "number" ? new Date(input) : input;
+var formatDateRange = (startInput, endInput, options = {}) => {
+  const now2 = options.now ?? /* @__PURE__ */ new Date();
+  const showTimeWhenSameDay = options.showTimeWhenSameDay ?? true;
+  const markToday = options.markToday ?? true;
+  const todayLabel = options.todayLabel ?? "today";
+  const separator = options.separator ?? " - ";
+  const monthPattern = options.monthFormat === "long" ? "MMMM" : "MMM";
+  const lowercaseAmPm = options.lowercaseAmPm ?? true;
+  const { locale } = options;
+  let start = toDate(startInput);
+  let end = toDate(endInput);
+  if (start.getTime() > end.getTime()) {
+    const tmp = start;
+    start = end;
+    end = tmp;
+  }
+  if (isNaN(start.getTime()) || isNaN(end.getTime())) return "";
+  const sameYear = dateFns.isSameYear(start, end);
+  const sameMonth = sameYear && dateFns.isSameMonth(start, end);
+  const sameDay = sameMonth && dateFns.isSameDay(start, end);
+  const isStartToday = dateFns.isSameDay(start, now2);
+  const isEndToday = dateFns.isSameDay(end, now2);
+  const appendToday = (base, isTodayFlag) => markToday && isTodayFlag ? `${base} (${todayLabel})` : base;
+  const fmt = (d, pattern) => locale ? dateFns.format(d, pattern, { locale }) : dateFns.format(d, pattern);
+  if (sameDay) {
+    const dayPart = appendToday(
+      fmt(start, `${monthPattern} d`),
+      isStartToday || isEndToday
+    );
+    if (!showTimeWhenSameDay) return dayPart;
+    const timePattern = "h:mma";
+    const formatTime = (d) => lowercaseAmPm ? fmt(d, timePattern).toLowerCase() : fmt(d, timePattern);
+    const startTime = formatTime(start);
+    const endTime = formatTime(end);
+    return `${dayPart}, ${startTime}${separator}${endTime}`;
+  }
+  if (sameMonth) {
+    const monthPart = fmt(start, monthPattern);
+    const startDay = fmt(start, "d");
+    const endDay = fmt(end, "d");
+    const startSegment = appendToday(startDay, isStartToday);
+    const endSegment = appendToday(endDay, isEndToday);
+    const yearPart = fmt(start, "yyyy");
+    return `${monthPart} ${startSegment}${separator}${endSegment}, ${yearPart}`;
+  }
+  if (sameYear) {
+    const startPart2 = appendToday(
+      fmt(start, `${monthPattern} d`),
+      isStartToday
+    );
+    const endPart2 = appendToday(fmt(end, `${monthPattern} d`), isEndToday);
+    const yearPart = fmt(start, "yyyy");
+    return `${startPart2}${separator}${endPart2}, ${yearPart}`;
+  }
+  const startPart = appendToday(
+    fmt(start, `${monthPattern} d, yyyy`),
+    isStartToday
+  );
+  const endPart = appendToday(fmt(end, `${monthPattern} d, yyyy`), isEndToday);
+  return `${startPart}${separator}${endPart}`;
+};
+var formatThreadDateRange = (startInput, endInput, options = {}) => formatDateRange(startInput, endInput, options);
+var adjustDate = (adjustment, baseDate = /* @__PURE__ */ new Date()) => {
+  let result = new Date(baseDate);
+  if (adjustment.seconds) result = dateFns.addSeconds(result, adjustment.seconds);
+  if (adjustment.minutes) result = dateFns.addMinutes(result, adjustment.minutes);
+  if (adjustment.hours) result = dateFns.addHours(result, adjustment.hours);
+  if (adjustment.days) result = dateFns.addDays(result, adjustment.days);
+  if (adjustment.weeks) result = dateFns.addWeeks(result, adjustment.weeks);
+  if (adjustment.businessDays)
+    result = dateFns.addBusinessDays(result, adjustment.businessDays);
+  if (adjustment.months) result = dateFns.addMonths(result, adjustment.months);
+  if (adjustment.years) result = dateFns.addYears(result, adjustment.years);
+  return result;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var now = () => Date.now();
+var toMs = (value, unit = "seconds") => {
+  const multipliers = {
+    seconds: 1e3,
+    minutes: 60 * 1e3,
+    hours: 60 * 60 * 1e3,
+    days: 24 * 60 * 60 * 1e3,
+    weeks: 7 * 24 * 60 * 60 * 1e3,
+    months: 30 * 24 * 60 * 60 * 1e3,
+    // approximate
+    years: 365 * 24 * 60 * 60 * 1e3
+    // approximate
+  };
+  return value * multipliers[unit];
+};
+
+// src/shared/flow.ts
+var flow_exports = {};
+__export(flow_exports, {
+  asyncPool: () => asyncPool,
+  debounce: () => debounce,
+  sleep: () => sleep2,
+  throttle: () => throttle
+});
+var throttle = (fn, ms) => {
+  let time = Date.now();
+  return (...args) => {
+    if (time + ms - Date.now() < 0) {
+      fn(...args);
+      time = Date.now();
+    }
+  };
+};
+var debounce = (fn, timeout) => {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      fn(...args);
+    }, timeout);
+  };
+};
+var sleep2 = (ms) => new Promise((res) => setTimeout(res, ms));
+async function* asyncPool(concurrency, iterable, iterator_fn) {
+  const executing = /* @__PURE__ */ new Set();
+  const consume = async () => {
+    const [promise, value] = await Promise.race(executing);
+    executing.delete(promise);
+    return value;
+  };
+  for (const item2 of iterable) {
+    const promise = (async () => await iterator_fn(item2, iterable))().then(
+      (value) => [promise, value]
+    );
+    executing.add(promise);
+    if (executing.size >= concurrency) {
+      yield await consume();
+    }
+  }
+  while (executing.size) {
+    yield await consume();
+  }
+}
+
+// src/shared/random.ts
+var random_exports = {};
+__export(random_exports, {
+  coinFlip: () => coinFlip,
+  date: () => date,
+  hexColor: () => hexColor,
+  item: () => item,
+  num: () => num,
+  shuffle: () => shuffle
+});
+var item = (xs) => {
+  const rand = Math.random() * xs.length;
+  const flooredRand = Math.floor(rand);
+  return xs[flooredRand];
+};
+var num = (props = {}) => {
+  const { min = 0, max = Number.MAX_SAFE_INTEGER } = props;
+  return Math.floor(Math.pow(10, 14) * Math.random() * Math.random()) % (max - min + 1) + min;
+};
+var shuffle = (xs) => {
+  return xs.reduceRight((r, _, __, s) => {
+    const randomItem = s.splice(0 | Math.random() * s.length, 1)[0];
+    return r.push(randomItem), r;
+  }, []);
+};
+var coinFlip = () => {
+  return Math.random() < 0.5;
+};
+var date = () => {
+  return new Date(+/* @__PURE__ */ new Date() - Math.floor(Math.random() * 1e13));
+};
+var hexColor = () => {
+  const hex = Math.floor(Math.random() * 16777215).toString(16);
+  if (hex.length !== 6) {
+    console.warn(`${hex} was not 6 characters. Regenerating.`);
+    return hexColor();
+  }
+  return hex;
+};
+
+// src/server/file.ts
+var file_exports = {};
+__export(file_exports, {
+  readFile: () => readFile
+});
+var readFile = (filePath, encoding = "utf-8") => {
+  return fs__default.default.readFileSync(filePath, encoding);
+};
+
+exports.Dict = dict_exports;
+exports.File = file_exports;
+exports.Flow = flow_exports;
+exports.Int = int_exports;
+exports.List = list_exports;
+exports.Money = money_exports;
+exports.Random = random_exports;
+exports.Str = str_exports;
+exports.Time = time_exports;

package/dist/server/index.d.cts

@@ -0,0 +1,17 @@
+export { d as Dict, f as Flow, i as Int, l as List, m as Money, r as Random, s as Str, t as Time } from '../random-DMErOOdk.cjs';
+import 'date-fns';
+
+/**
+ * Read file contents as string
+ * @param filePath
+ * @param encoding
+ * @returns
+ */
+declare const readFile: (filePath: string, encoding?: BufferEncoding) => string;
+
+declare const file_readFile: typeof readFile;
+declare namespace file {
+  export { file_readFile as readFile };
+}
+
+export { file as File };

package/dist/server/index.d.ts

@@ -0,0 +1,17 @@
+export { d as Dict, f as Flow, i as Int, l as List, m as Money, r as Random, s as Str, t as Time } from '../random-DMErOOdk.js';
+import 'date-fns';
+
+/**
+ * Read file contents as string
+ * @param filePath
+ * @param encoding
+ * @returns
+ */
+declare const readFile: (filePath: string, encoding?: BufferEncoding) => string;
+
+declare const file_readFile: typeof readFile;
+declare namespace file {
+  export { file_readFile as readFile };
+}
+
+export { file as File };