urlbat/dist/index.cjs

A library to join all parts of a url

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  default: () => src_default,
  joinParts: () => joinParts_default,
  urlbat: () => urlbat
});
module.exports = __toCommonJS(src_exports);

// src/joinParts.ts
var joinParts = (...parts) => {
  const filtered = parts.filter((part) => part.length > 0);
  if (filtered.length === 1)
    return filtered[0];
  let url = "";
  let alternate = false;
  parts.forEach((part) => {
    alternate = !alternate;
    if (alternate) {
      if (part[part.length - 1] === "/") {
        url += part;
        return;
      }
      url += part + "/";
      return;
    }
    if (part[0] === "/") {
      url += part.slice(1);
      return;
    }
    url += part;
  });
  const lastPart = parts[parts.length - 1];
  while (lastPart[lastPart.length - 1] !== "/" && url[url.length - 1] === "/") {
    url = url.slice(0, -1);
  }
  return url;
};
var joinParts_default = joinParts;

// src/index.ts
var assert = (item) => {
  if (item === 0 || typeof item === "boolean")
    return true;
  return !!item;
};
var defOpts = { array: "repeat" };
var urlbat = (base, segments, params, opts) => {
  const FROZEN_SEGMENTS = typeof segments === "string" ? joinParts_default(base, segments) : base;
  const FROZEN_PARAMS = typeof segments === "string" ? { ...params } : { ...segments };
  const FROZEN_SETTINGS = (typeof segments === "string" ? opts : params) || defOpts;
  const usedParams = [];
  let url = FROZEN_SEGMENTS;
  if (Object.values(FROZEN_PARAMS).length > 0) {
    url = url.split("/").map((seg) => {
      if (seg[0] === ":") {
        let dotIdx = seg.indexOf(".");
        if (dotIdx === -1) {
          dotIdx = seg.length;
        }
        const key = seg.slice(1, dotIdx);
        const value = FROZEN_PARAMS[key];
        if (!assert(value)) {
          throw new Error("path segments can't be falsy, got " + String(value));
        }
        usedParams.push(key);
        return encodeURIComponent(String(value)) + seg.slice(dotIdx);
      }
      return seg;
    }).join("/");
  }
  usedParams.forEach((key) => {
    delete FROZEN_PARAMS[key];
  });
  const query = new URLSearchParams({});
  Object.entries(FROZEN_PARAMS).filter(([, param]) => assert(param)).sort(([a], [b]) => {
    if (a > b)
      return 1;
    if (a < b)
      return -1;
    return 0;
  }).forEach(([key, value]) => {
    if (Array.isArray(value)) {
      switch (FROZEN_SETTINGS.array) {
        case "comma":
          query.append(key, value.join(","));
          break;
        case "stringify":
          query.append(key, JSON.stringify(value));
          break;
        default:
          value.forEach((item) => query.append(key, item));
          break;
      }
      return;
    }
    if (typeof value === "object") {
      query.append(key, JSON.stringify(value));
      return;
    }
    query.append(key, String(value));
  });
  if (!query.toString()) {
    return url;
  }
  return url + "?" + query.toString();
};
var src_default = urlbat;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  joinParts,
  urlbat
});