@quikturn/logos 0.2.0

package/dist/index.mjs

@@ -0,0 +1,294 @@
+// src/constants.ts
+var BASE_URL = "https://logos.getquikturn.io";
+var DEFAULT_WIDTH = 128;
+var MAX_WIDTH = 800;
+var MAX_WIDTH_SERVER = 1200;
+var DEFAULT_FORMAT = "image/png";
+var SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/avif"
+]);
+var FORMAT_ALIASES = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  avif: "image/avif"
+};
+var RATE_LIMITS = {
+  free: { requests: 100, windowSeconds: 60 },
+  launch: { requests: 500, windowSeconds: 60 },
+  growth: { requests: 5e3, windowSeconds: 60 },
+  enterprise: { requests: 5e4, windowSeconds: 60 }
+};
+var SERVER_RATE_LIMITS = {
+  launch: { requests: 1e3, windowSeconds: 60 },
+  growth: { requests: 1e4, windowSeconds: 60 },
+  enterprise: { requests: 1e5, windowSeconds: 60 }
+};
+var TIERS = ["free", "launch", "growth", "enterprise"];
+var KEY_TYPES = ["publishable", "secret"];
+var MONTHLY_LIMITS = {
+  free: 5e5,
+  launch: 1e6,
+  growth: 5e6,
+  enterprise: 1e7
+};
+
+// src/errors.ts
+var LogoError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.name = "LogoError";
+    this.code = code;
+    this.status = status;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var DomainValidationError = class extends LogoError {
+  constructor(message, domain) {
+    super(message, "DOMAIN_VALIDATION_ERROR");
+    this.name = "DomainValidationError";
+    this.domain = domain;
+  }
+};
+var RateLimitError = class extends LogoError {
+  constructor(message, retryAfter, remaining, resetAt) {
+    super(message, "RATE_LIMIT_ERROR", 429);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+    this.remaining = remaining;
+    this.resetAt = resetAt;
+  }
+};
+var QuotaExceededError = class extends LogoError {
+  constructor(message, retryAfter, limit, used) {
+    super(message, "QUOTA_EXCEEDED_ERROR", 429);
+    this.name = "QuotaExceededError";
+    this.retryAfter = retryAfter;
+    this.limit = limit;
+    this.used = used;
+  }
+};
+var AuthenticationError = class extends LogoError {
+  constructor(message) {
+    super(message, "AUTHENTICATION_ERROR", 401);
+    this.name = "AuthenticationError";
+  }
+};
+var ForbiddenError = class extends LogoError {
+  constructor(message, reason) {
+    super(message, "FORBIDDEN_ERROR", 403);
+    this.name = "ForbiddenError";
+    this.reason = reason;
+  }
+};
+var NotFoundError = class extends LogoError {
+  constructor(message, domain) {
+    super(message, "NOT_FOUND_ERROR", 404);
+    this.name = "NotFoundError";
+    this.domain = domain;
+  }
+};
+var ScrapeTimeoutError = class extends LogoError {
+  constructor(message, jobId, elapsed) {
+    super(message, "SCRAPE_TIMEOUT_ERROR");
+    this.name = "ScrapeTimeoutError";
+    this.jobId = jobId;
+    this.elapsed = elapsed;
+  }
+};
+var BadRequestError = class extends LogoError {
+  constructor(message) {
+    super(message, "BAD_REQUEST_ERROR", 400);
+    this.name = "BadRequestError";
+  }
+};
+
+// src/url-builder.ts
+var IP_ADDRESS_RE = /^(\d{1,3}\.){3}\d{1,3}$/;
+var LABEL_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+function validateDomain(domain) {
+  const normalized = domain.trim().toLowerCase();
+  const clean = normalized.endsWith(".") ? normalized.slice(0, -1) : normalized;
+  if (clean.length === 0) {
+    throw new DomainValidationError("Domain must not be empty", domain);
+  }
+  if (clean.includes("://")) {
+    throw new DomainValidationError(
+      'Domain must not include a protocol scheme (e.g. remove "https://")',
+      domain
+    );
+  }
+  if (clean.includes("/")) {
+    throw new DomainValidationError(
+      "Domain must not include a path \u2014 provide only the hostname",
+      domain
+    );
+  }
+  if (IP_ADDRESS_RE.test(clean)) {
+    throw new DomainValidationError(
+      "IP addresses are not supported \u2014 provide a domain name",
+      domain
+    );
+  }
+  if (clean === "localhost") {
+    throw new DomainValidationError(
+      '"localhost" is not a valid domain',
+      domain
+    );
+  }
+  if (clean.length > 253) {
+    throw new DomainValidationError(
+      `Domain exceeds maximum length of 253 characters (got ${clean.length})`,
+      domain
+    );
+  }
+  const labels = clean.split(".");
+  if (labels.length < 2) {
+    throw new DomainValidationError(
+      'Domain must contain at least two labels (e.g. "example.com")',
+      domain
+    );
+  }
+  for (const label of labels) {
+    if (label.length === 0) {
+      throw new DomainValidationError(
+        "Domain contains an empty label (consecutive dots)",
+        domain
+      );
+    }
+    if (label.length > 63) {
+      throw new DomainValidationError(
+        `Label "${label}" exceeds maximum length of 63 characters (got ${label.length})`,
+        domain
+      );
+    }
+    if (!LABEL_RE.test(label)) {
+      throw new DomainValidationError(
+        `Label "${label}" contains invalid characters \u2014 only letters, digits, and hyphens are allowed, and labels must not start or end with a hyphen`,
+        domain
+      );
+    }
+  }
+  return clean;
+}
+function resolveFormat(format) {
+  let candidate = format;
+  if (candidate.startsWith("image/")) {
+    candidate = candidate.slice(6);
+  }
+  if (candidate in FORMAT_ALIASES) {
+    return candidate;
+  }
+  if (SUPPORTED_FORMATS.has(format)) {
+    const shorthand = format.slice(6);
+    if (shorthand in FORMAT_ALIASES) {
+      return shorthand;
+    }
+  }
+  return void 0;
+}
+function logoUrl(domain, options) {
+  const validDomain = validateDomain(domain);
+  const {
+    token,
+    size,
+    width,
+    greyscale,
+    theme,
+    format,
+    autoScrape,
+    baseUrl
+  } = options ?? {};
+  const maxWidth = token?.startsWith("sk_") ? MAX_WIDTH_SERVER : MAX_WIDTH;
+  let resolvedSize = size ?? width ?? DEFAULT_WIDTH;
+  if (resolvedSize <= 0) {
+    resolvedSize = DEFAULT_WIDTH;
+  }
+  resolvedSize = Math.max(1, Math.min(resolvedSize, maxWidth));
+  const resolvedFormat = format ? resolveFormat(format) : void 0;
+  const effectiveBaseUrl = baseUrl ?? BASE_URL;
+  const url = new URL(`${effectiveBaseUrl}/${validDomain}`);
+  if (token !== void 0) {
+    url.searchParams.set("token", token);
+  }
+  if (resolvedSize !== DEFAULT_WIDTH) {
+    url.searchParams.set("size", String(resolvedSize));
+  }
+  if (greyscale === true) {
+    url.searchParams.set("greyscale", "1");
+  }
+  if (theme === "light" || theme === "dark") {
+    url.searchParams.set("theme", theme);
+  }
+  if (resolvedFormat !== void 0) {
+    url.searchParams.set("format", resolvedFormat);
+  }
+  if (autoScrape === true) {
+    url.searchParams.set("autoScrape", "true");
+  }
+  return url.toString();
+}
+
+// src/headers.ts
+function safeParseInt(value, fallback) {
+  if (value === null) return fallback;
+  const parsed = parseInt(value, 10);
+  return Number.isNaN(parsed) ? fallback : parsed;
+}
+function safeParseFloat(value, fallback) {
+  if (value === null) return fallback;
+  const parsed = parseFloat(value);
+  return Number.isNaN(parsed) ? fallback : parsed;
+}
+function parseLogoHeaders(headers) {
+  const cacheStatus = headers.get("X-Cache-Status");
+  const rateLimitRemaining = safeParseInt(headers.get("X-RateLimit-Remaining"), 0);
+  const rateLimitReset = safeParseInt(headers.get("X-RateLimit-Reset"), 0);
+  const quotaRemaining = safeParseInt(headers.get("X-Quota-Remaining"), 0);
+  const quotaLimit = safeParseInt(headers.get("X-Quota-Limit"), 0);
+  const tokenPrefix = headers.get("X-Quikturn-Token") ?? void 0;
+  const transformApplied = headers.get("X-Transformation-Applied") === "true";
+  const VALID_TRANSFORM_STATUSES = /* @__PURE__ */ new Set([
+    "not-requested",
+    "unsupported-format",
+    "transformation-error"
+  ]);
+  const rawTransformStatus = headers.get("X-Transformation-Status");
+  const transformStatus = rawTransformStatus && VALID_TRANSFORM_STATUSES.has(rawTransformStatus) ? rawTransformStatus : void 0;
+  const rawTransformMethod = headers.get("X-Transformation-Method");
+  const transformMethod = rawTransformMethod === "images-binding" ? "images-binding" : void 0;
+  const transformWidth = safeParseInt(headers.get("X-Transformation-Width"), void 0);
+  const transformGreyscale = headers.get("X-Transformation-Greyscale") === "true" ? true : void 0;
+  const transformGamma = safeParseFloat(headers.get("X-Transformation-Gamma"), void 0);
+  return {
+    cache: { status: cacheStatus === "HIT" ? "HIT" : "MISS" },
+    rateLimit: {
+      remaining: rateLimitRemaining,
+      reset: new Date(rateLimitReset * 1e3)
+    },
+    quota: {
+      remaining: quotaRemaining,
+      limit: quotaLimit
+    },
+    transformation: {
+      applied: transformApplied,
+      ...transformStatus ? { status: transformStatus } : {},
+      ...transformMethod ? { method: transformMethod } : {},
+      ...transformWidth !== void 0 ? { width: transformWidth } : {},
+      ...transformGreyscale !== void 0 ? { greyscale: transformGreyscale } : {},
+      ...transformGamma !== void 0 ? { gamma: transformGamma } : {}
+    },
+    ...tokenPrefix !== void 0 ? { tokenPrefix } : {}
+  };
+}
+function parseRetryAfter(headers) {
+  const value = headers.get("Retry-After");
+  if (value === null) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+export { AuthenticationError, BASE_URL, BadRequestError, DEFAULT_FORMAT, DEFAULT_WIDTH, DomainValidationError, FORMAT_ALIASES, ForbiddenError, KEY_TYPES, LogoError, MAX_WIDTH, MAX_WIDTH_SERVER, MONTHLY_LIMITS, NotFoundError, QuotaExceededError, RATE_LIMITS, RateLimitError, SERVER_RATE_LIMITS, SUPPORTED_FORMATS, ScrapeTimeoutError, TIERS, logoUrl, parseLogoHeaders, parseRetryAfter };