@stacksjs/browser 0.70.57 → 0.70.59

package/dist/model-loader.js

@@ -0,0 +1,61 @@
+import { createBrowserModel } from "bun-query-builder/browser";
+const modelModules = typeof import.meta.glob === "function" ? import.meta.glob("~/app/Models/*.ts", { eager: !0 }) : {};
+export function loadBrowserModels() {
+  if (typeof window > "u")
+    return;
+  if (!window.StacksBrowser)
+    window.StacksBrowser = {};
+  for (const [path, module] of Object.entries(modelModules)) {
+    const definition = module.default;
+    if (!definition || !definition.name) {
+      console.warn(`[model-loader] Skipping ${path}: no valid model definition`);
+      continue;
+    }
+    if (!definition.traits?.useApi?.uri)
+      continue;
+    try {
+      const browserModel = createBrowserModel({
+        name: definition.name,
+        table: definition.table,
+        primaryKey: definition.primaryKey || "id",
+        traits: {
+          useUuid: definition.traits?.useUuid ?? !1,
+          useTimestamps: definition.traits?.useTimestamps ?? !0,
+          useSoftDeletes: definition.traits?.useSoftDeletes ?? !1,
+          useApi: definition.traits?.useApi
+        },
+        attributes: extractBrowserAttributes(definition.attributes ?? {})
+      });
+      window.StacksBrowser[definition.name] = browserModel;
+    } catch (error) {
+      console.error(`[model-loader] Failed to create browser model for ${definition.name}:`, error);
+    }
+  }
+}
+function extractBrowserAttributes(attributes) {
+  const browserAttrs = {};
+  for (const [name, attr] of Object.entries(attributes))
+    browserAttrs[name] = {
+      fillable: attr.fillable ?? !1,
+      hidden: attr.hidden ?? !1,
+      guarded: attr.guarded ?? !1,
+      nullable: attr.nullable ?? !1
+    };
+  return browserAttrs;
+}
+export function getBrowserModel(name) {
+  if (typeof window > "u")
+    return null;
+  return window.StacksBrowser?.[name] ?? null;
+}
+export function getBrowserModelNames() {
+  if (typeof window > "u")
+    return [];
+  const stacksBrowser = window.StacksBrowser;
+  if (!stacksBrowser)
+    return [];
+  return Object.keys(stacksBrowser).filter((key) => {
+    const value = stacksBrowser[key];
+    return value != null && typeof value.all === "function" && typeof value.find === "function";
+  });
+}

package/dist/types/dashboard.js

@@ -0,0 +1,3 @@
+export function isGeneralError(error) {
+  return "error" in error;
+}

package/dist/utils/base.js

@@ -0,0 +1,4 @@
+export { toString } from "@stacksjs/strings";
+export async function loop(times, callback) {
+  Array.from({ length: times }).forEach(async (_, i) => await callback(i));
+}

package/dist/utils/billable.js

@@ -0,0 +1,64 @@
+import { loadStripe } from "@stripe/stripe-js";
+const stacksConfig = globalThis.__STACKS_CONFIG__ || {};
+export const publishableKey = stacksConfig.FRONTEND_STRIPE_PUBLIC_KEY || "";
+let client;
+export async function loadCardElement(clientSecret) {
+  client = await loadStripe(publishableKey);
+  const cardElement = client.elements({ clientSecret }).create("card");
+  cardElement.mount("#card-element");
+  return cardElement;
+}
+export async function loadPaymentElement(clientSecret) {
+  client = await loadStripe(publishableKey);
+  const elements = client.elements({ clientSecret });
+  elements.create("payment", {
+    fields: { billingDetails: "auto" }
+  }).mount("#payment-element");
+  return elements;
+}
+export async function confirmCardSetup(clientSecret, elements) {
+  const data = await client.confirmCardSetup(clientSecret, { payment_method: { card: elements } }), { setupIntent, error } = data;
+  return { setupIntent, error };
+}
+export async function confirmCardPayment(clientSecret, elements) {
+  try {
+    const data = await client.confirmCardPayment(clientSecret, {
+      payment_method: {
+        card: elements,
+        billing_details: {
+          name: stacksConfig.USER_NAME || ""
+        }
+      }
+    }), { paymentIntent, error } = data;
+    return { paymentIntent, error };
+  } catch (err) {
+    console.error("Error confirming card payment:", err);
+    return { paymentIntent: null, error: err };
+  }
+}
+export async function createPaymentMethod(elements) {
+  try {
+    const data = await client.createPaymentMethod({
+      type: "card",
+      card: elements
+    }), { paymentIntent, error } = data;
+    return { paymentIntent, error };
+  } catch (err) {
+    console.error("Error confirming card payment:", err);
+    return { paymentIntent: null, error: err };
+  }
+}
+export async function confirmPayment(elements) {
+  try {
+    const data = await client.confirmPayment({
+      elements,
+      confirmParams: {
+        return_url: `${window.location.origin}/settings/billing`
+      }
+    }), { paymentIntent, error } = data;
+    return { paymentIntent, error };
+  } catch (err) {
+    console.error("Error confirming card payment:", err);
+    return { paymentIntent: null, error: err };
+  }
+}

package/dist/utils/date.js

@@ -0,0 +1,2 @@
+export { useDateFormat, useNow } from "@stacksjs/composables";
+export { format, parse } from "@stacksjs/datetime";

package/dist/utils/debounce.js

@@ -0,0 +1,43 @@
+export function debounce(fn, wait = 0, options = {}) {
+  const { leading = !1, trailing = !0 } = options;
+  let timeout = null, lastArgs = null, lastThis = null, result;
+  const invokeFunc = () => {
+    if (lastArgs) {
+      result = fn.apply(lastThis, lastArgs);
+      lastArgs = null;
+      lastThis = null;
+    }
+    return result;
+  }, cancel = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+    lastArgs = null;
+    lastThis = null;
+  }, flush = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+      return invokeFunc();
+    }
+    return result;
+  }, debounced = function(...args) {
+    lastArgs = args;
+    lastThis = this;
+    const shouldCallNow = leading && !timeout;
+    if (timeout)
+      clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      timeout = null;
+      if (trailing && lastArgs)
+        invokeFunc();
+    }, wait);
+    if (shouldCallNow)
+      return invokeFunc();
+    return result;
+  };
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}

package/dist/utils/fetch.js

@@ -0,0 +1,94 @@
+let loading = !1, token = "";
+const baseURL = "/";
+function appendParam(search, key, value) {
+  if (value === void 0 || value === null)
+    return;
+  if (Array.isArray(value)) {
+    for (const v of value)
+      appendParam(search, key, v);
+    return;
+  }
+  if (typeof value === "object") {
+    search.append(key, JSON.stringify(value));
+    return;
+  }
+  search.append(key, String(value));
+}
+function buildUrl(url, params) {
+  const full = /^https?:\/\//i.test(url) ? url : `${baseURL.replace(/\/$/, "")}/${url.replace(/^\//, "")}`;
+  if (!params || Object.keys(params).length === 0)
+    return full;
+  const search = new URLSearchParams;
+  for (const [key, value] of Object.entries(params))
+    appendParam(search, key, value);
+  const qs = search.toString();
+  if (!qs)
+    return full;
+  return full.includes("?") ? `${full}&${qs}` : `${full}?${qs}`;
+}
+function applyAuth(headers) {
+  const h = headers ?? new Headers;
+  if (token && !h.has("Authorization"))
+    h.set("Authorization", `Bearer ${token}`);
+  return h;
+}
+async function parseBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json"))
+    return await response.json();
+  if (contentType.startsWith("text/") || contentType.includes("xml"))
+    return await response.text();
+  return await response.blob();
+}
+async function request(method, url, params, headers) {
+  const sendsBody = method !== "GET" && method !== "DELETE", finalUrl = sendsBody ? buildUrl(url) : buildUrl(url, params), finalHeaders = applyAuth(headers), init = { method, headers: finalHeaders };
+  if (sendsBody && params !== void 0) {
+    if (!finalHeaders.has("Content-Type"))
+      finalHeaders.set("Content-Type", "application/json");
+    init.body = JSON.stringify(params);
+  }
+  if (sendsBody)
+    loading = !0;
+  try {
+    const response = await fetch(finalUrl, init);
+    if (!response.ok) {
+      const errorBody = await parseBody(response).catch(() => null), error = Error(`Request failed with status ${response.status}`);
+      error.status = response.status;
+      error.data = errorBody;
+      throw error;
+    }
+    return await parseBody(response);
+  } finally {
+    if (sendsBody)
+      loading = !1;
+  }
+}
+async function get(url, params, headers) {
+  return await request("GET", url, params, headers);
+}
+async function post(url, params, headers) {
+  return await request("POST", url, params, headers);
+}
+async function patch(url, params, headers) {
+  return await request("PATCH", url, params, headers);
+}
+async function put(url, params, headers) {
+  return await request("PUT", url, params, headers);
+}
+async function destroy(url, params, headers) {
+  return await request("DELETE", url, params, headers);
+}
+function setToken(authToken) {
+  token = authToken;
+}
+export const Fetch = {
+  get,
+  post,
+  patch,
+  put,
+  destroy,
+  baseURL,
+  token,
+  setToken,
+  loading
+};

package/dist/utils/function.js

@@ -0,0 +1,7 @@
+export function batchInvoke(functions) {
+  functions.forEach((fn) => fn?.());
+}
+export function tap(value, callback) {
+  callback(value);
+  return value;
+}

package/dist/utils/guards.js

@@ -0,0 +1,12 @@
+export function notNullish(v) {
+  return v != null;
+}
+export function noNull(v) {
+  return v !== null;
+}
+export function notUndefined(v) {
+  return v !== void 0;
+}
+export function isTruthy(v) {
+  return Boolean(v);
+}

package/dist/utils/index.js

@@ -0,0 +1,17 @@
+export * from "./base";
+export * from "./billable";
+export * from "./date";
+export * from "./debounce";
+export * from "./fetch";
+export * from "./function";
+export * from "./guards";
+export * from "./lazy";
+export * from "./math";
+export * from "./plans";
+export * from "./promise";
+export * from "./random";
+export * from "./regex";
+export * from "./retry";
+export * from "./sleep";
+export * from "./throttle";
+export * from "./vendors";

package/dist/utils/lazy.js

@@ -0,0 +1,9 @@
+export function lazy(getter) {
+  return {
+    get value() {
+      const value = getter();
+      Object.defineProperty(this, "value", { value });
+      return value;
+    }
+  };
+}

package/dist/utils/math.js

@@ -0,0 +1,23 @@
+export const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+export function rand(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+export {
+  and,
+  logicNot,
+  logicOr,
+  or,
+  useAbs,
+  useAverage,
+  useCeil,
+  useClamp,
+  useFloor,
+  useMax,
+  useMin,
+  usePrecision,
+  useRound,
+  useSum,
+  useTrunc
+} from "@stacksjs/composables";

package/dist/utils/plans.js

@@ -0,0 +1,135 @@
+export const saas = {
+  plans: [
+    {
+      productName: "Stacks Hobby",
+      description: "All the Stacks features.",
+      pricing: [
+        {
+          key: "stacks_hobby_early_monthly",
+          price: 1900,
+          interval: "month",
+          currency: "usd"
+        },
+        {
+          key: "stacks_hobby_launch_monthly",
+          price: 2900,
+          interval: "month",
+          currency: "usd"
+        },
+        {
+          key: "stacks_hobby_monthly",
+          price: 3900,
+          interval: "month",
+          currency: "usd"
+        },
+        {
+          key: "stacks_hobby_yearly",
+          price: 37900,
+          interval: "year",
+          currency: "usd"
+        }
+      ],
+      metadata: {
+        createdBy: "admin",
+        version: "1.0.0"
+      }
+    },
+    {
+      productName: "Stacks Pro",
+      description: "All the Stacks features, including being able to invite team members.",
+      pricing: [
+        {
+          key: "stacks_pro_early_monthly",
+          price: 3900,
+          interval: "month",
+          currency: "usd"
+        },
+        {
+          key: "stacks_pro_monthly",
+          price: 5900,
+          interval: "month",
+          currency: "usd"
+        },
+        {
+          key: "stacks_pro_yearly",
+          price: 57900,
+          interval: "year",
+          currency: "usd"
+        },
+        {
+          key: "stacks_pro_early_yearly",
+          price: 39000,
+          interval: "year",
+          currency: "usd"
+        }
+      ],
+      metadata: {
+        createdBy: "admin",
+        version: "1.0.0"
+      }
+    },
+    {
+      productName: "Stacks Lifetime",
+      description: "One-time lifetime access to all Stacks features.",
+      pricing: [
+        {
+          key: "stacks_hobby_early_lifetime",
+          price: 17900,
+          currency: "usd"
+        },
+        {
+          key: "stacks_hobby_launch_lifetime",
+          price: 27900,
+          currency: "usd"
+        },
+        {
+          key: "stacks_hobby_lifetime",
+          price: 47900,
+          currency: "usd"
+        },
+        {
+          key: "stacks_pro_early_lifetime",
+          price: 27900,
+          currency: "usd"
+        },
+        {
+          key: "stacks_pro_launch_lifetime",
+          price: 37900,
+          currency: "usd"
+        },
+        {
+          key: "stacks_pro_lifetime",
+          price: 74900,
+          currency: "usd"
+        }
+      ],
+      metadata: {
+        createdBy: "admin",
+        version: "1.0.0"
+      }
+    }
+  ],
+  webhook: {
+    endpoint: "your-webhook-endpoint",
+    secret: "your-webhook-secret"
+  },
+  currencies: ["usd"],
+  coupons: [],
+  products: [
+    {
+      name: "Stacks Hobby",
+      description: "All the Stacks features.",
+      images: ["image-url"]
+    },
+    {
+      name: "Stacks Pro",
+      description: "All the Stacks features, including team invites.",
+      images: ["image-url"]
+    },
+    {
+      name: "Stacks Lifetime",
+      description: "Lifetime access to Stacks features.",
+      images: ["image-url"]
+    }
+  ]
+};

package/dist/utils/promise.js

@@ -0,0 +1,55 @@
+export function createSingletonPromise(fn) {
+  let _promise;
+  function wrapper() {
+    if (!_promise)
+      _promise = fn();
+    return _promise;
+  }
+  wrapper.reset = async () => {
+    const _prev = _promise;
+    _promise = void 0;
+    if (_prev)
+      await _prev;
+  };
+  return wrapper;
+}
+export function createPromiseLock() {
+  let currentPromise = Promise.resolve();
+  const queue = [];
+  return {
+    async run(fn) {
+      const taskPromise = (async () => {
+        await currentPromise;
+        return fn();
+      })();
+      queue.push(taskPromise);
+      currentPromise = taskPromise.catch(() => {}).finally(() => {
+        const index = queue.indexOf(taskPromise);
+        if (index > -1)
+          queue.splice(index, 1);
+      });
+      return taskPromise;
+    },
+    async wait() {
+      while (queue.length > 0)
+        await Promise.all(queue);
+    },
+    isWaiting() {
+      return queue.length > 0;
+    },
+    clear() {
+      queue.length = 0;
+      currentPromise = Promise.resolve();
+    }
+  };
+}
+export function createControlledPromise() {
+  let resolve, reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  promise.resolve = resolve;
+  promise.reject = reject;
+  return promise;
+}

package/dist/utils/random.js

@@ -0,0 +1,67 @@
+const POOL_SIZE_MULTIPLIER = 128;
+let pool = null, poolOffset = 0;
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = new Uint8Array(bytes * POOL_SIZE_MULTIPLIER);
+    globalThis.crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    globalThis.crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function randomPool(bytes) {
+  fillPool(bytes |= 0);
+  if (!pool)
+    throw Error("Pool is not initialized");
+  return pool.subarray(poolOffset - bytes, poolOffset);
+}
+function customRandom(alphabet, defaultSize, getRandom) {
+  const mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1, step = Math.ceil(1.6 * mask * defaultSize / alphabet.length);
+  return (size = defaultSize) => {
+    let id = "";
+    while (!0) {
+      const bytes = getRandom(step);
+      let i = step;
+      while (i--) {
+        const byte = bytes[i];
+        if (byte === void 0)
+          continue;
+        id += alphabet[byte & mask] || "";
+        if (id.length >= size)
+          return id;
+      }
+    }
+  };
+}
+function customAlphabet(alphabet, size = 21) {
+  return customRandom(alphabet, size, randomPool);
+}
+function randomNonSecure(size = 21) {
+  let id = "", i = size | 0;
+  while (i--)
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+}
+function random(size = 21) {
+  fillPool(size |= 0);
+  if (!pool)
+    return "";
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    const byte = pool[i];
+    if (byte === void 0)
+      continue;
+    id += urlAlphabet[byte & 63];
+  }
+  return id;
+}
+
+export {
+  customAlphabet,
+  customRandom,
+  random,
+  randomNonSecure
+};

package/dist/utils/regex.js

@@ -0,0 +1,29 @@
+export {
+  anyOf,
+  carriageReturn,
+  caseInsensitive,
+  char,
+  charIn,
+  charNotIn,
+  digit,
+  dotAll,
+  exactly,
+  global,
+  letter,
+  linefeed,
+  maybe,
+  multiline,
+  not,
+  oneOrMore,
+  sticky,
+  tab,
+  unicode,
+  whitespace,
+  withIndices,
+  word,
+  wordBoundary,
+  wordChar
+} from "magic-regexp";
+export function createRegExp(pattern, options = {}) {
+  return new RegExp(pattern, options.flags);
+}

package/dist/utils/retry.js

@@ -0,0 +1,28 @@
+export function retry(fn, options = {}) {
+  const { retries = 3, initialDelay = 1000, backoffFactor = 2, jitter = !0 } = options;
+  return new Promise((resolve, reject) => {
+    let attemptCount = 0;
+    const attempt = async () => {
+      try {
+        resolve(await fn());
+      } catch (err) {
+        if (attemptCount >= retries)
+          reject(err);
+        else {
+          const delay = calculateDelay(attemptCount, initialDelay, backoffFactor, jitter);
+          setTimeout(() => attempt(), delay);
+          attemptCount++;
+        }
+      }
+    };
+    attempt();
+  });
+}
+export function calculateDelay(attemptCount, initialDelay, backoffFactor, jitter) {
+  let delay = initialDelay * backoffFactor ** attemptCount;
+  if (jitter) {
+    const random = Math.random(), jitterValue = delay * 0.3;
+    delay = delay + jitterValue * (random - 0.5) * 2;
+  }
+  return delay;
+}