featuredrop 1.4.0 → 2.2.0

package/dist/cms.cjs

@@ -0,0 +1,835 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var zod = require('zod');
+
+// src/changelog-as-code.ts
+
+// src/dependencies.ts
+function getDirectDependencies(feature) {
+  const dependsOn = feature.dependsOn;
+  if (!dependsOn) return [];
+  const seen = dependsOn.seen ?? [];
+  const clicked = dependsOn.clicked ?? [];
+  const dismissed = dependsOn.dismissed ?? [];
+  const unique = /* @__PURE__ */ new Set();
+  for (const id of [...seen, ...clicked, ...dismissed]) {
+    if (id) unique.add(id);
+  }
+  return Array.from(unique);
+}
+function hasDependencyCycle(manifest) {
+  const ids = new Set(manifest.map((feature) => feature.id));
+  const outgoing = /* @__PURE__ */ new Map();
+  const indegree = /* @__PURE__ */ new Map();
+  for (const feature of manifest) {
+    outgoing.set(feature.id, /* @__PURE__ */ new Set());
+    indegree.set(feature.id, 0);
+  }
+  for (const feature of manifest) {
+    for (const dependencyId of getDirectDependencies(feature)) {
+      if (!ids.has(dependencyId)) continue;
+      const edges = outgoing.get(dependencyId);
+      if (!edges || edges.has(feature.id)) continue;
+      edges.add(feature.id);
+      indegree.set(feature.id, (indegree.get(feature.id) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const feature of manifest) {
+    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
+  }
+  let visited = 0;
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id) continue;
+    visited += 1;
+    const edges = outgoing.get(id);
+    if (!edges) continue;
+    for (const nextId of edges) {
+      const nextDegree = (indegree.get(nextId) ?? 0) - 1;
+      indegree.set(nextId, nextDegree);
+      if (nextDegree === 0) queue.push(nextId);
+    }
+  }
+  return visited !== manifest.length;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isValidDate(value) {
+  return Number.isFinite(new Date(value).getTime());
+}
+var nonEmptyString = zod.z.string().trim().min(1, "must be a non-empty string");
+var isoDateString = nonEmptyString.refine(isValidDate, {
+  message: "must be a valid date",
+  params: { featuredropCode: "invalid_date" }
+});
+var dependsOnSchema = zod.z.object({
+  seen: zod.z.array(zod.z.string()).optional(),
+  clicked: zod.z.array(zod.z.string()).optional(),
+  dismissed: zod.z.array(zod.z.string()).optional()
+}).optional();
+var ctaSchema = zod.z.object({
+  label: nonEmptyString,
+  url: nonEmptyString
+}).optional();
+var featureEntrySchema = zod.z.object({
+  id: nonEmptyString,
+  label: nonEmptyString,
+  releasedAt: isoDateString,
+  showNewUntil: isoDateString,
+  description: zod.z.string().optional(),
+  flagKey: zod.z.string().optional(),
+  product: zod.z.string().optional(),
+  url: zod.z.string().optional(),
+  image: zod.z.string().optional(),
+  type: zod.z.enum(["feature", "improvement", "fix", "breaking"]).optional(),
+  priority: zod.z.enum(["critical", "normal", "low"]).optional(),
+  cta: ctaSchema,
+  meta: zod.z.record(zod.z.unknown()).optional(),
+  dependsOn: dependsOnSchema
+}).passthrough();
+zod.z.array(featureEntrySchema);
+function toIssuePath(path) {
+  if (path.length === 0) return "$";
+  let output = "";
+  for (const part of path) {
+    if (typeof part === "number") output += `[${part}]`;
+    else output += output ? `.${part}` : part;
+  }
+  return output;
+}
+function mapZodIssue(issue) {
+  const codeParam = issue.params?.featuredropCode;
+  if (codeParam === "invalid_date") {
+    return {
+      path: toIssuePath(issue.path),
+      message: issue.message,
+      code: "invalid_date"
+    };
+  }
+  if (issue.code === "invalid_type") {
+    return {
+      path: toIssuePath(issue.path),
+      message: issue.message,
+      code: issue.received === "undefined" ? "missing_required" : "invalid_type"
+    };
+  }
+  return {
+    path: toIssuePath(issue.path),
+    message: issue.message,
+    code: "invalid_value"
+  };
+}
+var UNSAFE_META_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeUrl(value) {
+  const normalized = value.trim();
+  if (!normalized) return false;
+  if (/^(\/|\.\/|\.\.\/|\?|#)/.test(normalized)) return true;
+  if (/^https?:\/\//i.test(normalized)) return true;
+  return false;
+}
+function findUnsafeMetaPath(value, path = "meta") {
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const nested = findUnsafeMetaPath(value[index], `${path}[${index}]`);
+      if (nested) return nested;
+    }
+    return null;
+  }
+  if (!isRecord(value)) return null;
+  for (const [key, nestedValue] of Object.entries(value)) {
+    if (UNSAFE_META_KEYS.has(key)) {
+      return `${path}.${key}`;
+    }
+    const nested = findUnsafeMetaPath(nestedValue, `${path}.${key}`);
+    if (nested) return nested;
+  }
+  return null;
+}
+function validateFeatureEntry(raw, index) {
+  if (!isRecord(raw)) {
+    return {
+      issues: [
+        {
+          path: `[${index}]`,
+          message: "Feature entry must be an object",
+          code: "invalid_type"
+        }
+      ]
+    };
+  }
+  const parsed = featureEntrySchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      issues: parsed.error.issues.map((issue) => ({
+        ...mapZodIssue(issue),
+        path: `[${index}]${issue.path.length > 0 ? `.${toIssuePath(issue.path)}` : ""}`
+      }))
+    };
+  }
+  return {
+    issues: [],
+    entry: parsed.data
+  };
+}
+function validateManifest(data) {
+  const errors = [];
+  if (!Array.isArray(data)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "$",
+          message: "Manifest must be an array",
+          code: "invalid_type"
+        }
+      ]
+    };
+  }
+  const entries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  data.forEach((item, index) => {
+    const result = validateFeatureEntry(item, index);
+    errors.push(...result.issues);
+    if (!result.entry) return;
+    if (seenIds.has(result.entry.id)) {
+      errors.push({
+        path: `[${index}].id`,
+        message: `Duplicate feature id "${result.entry.id}"`,
+        code: "duplicate_id"
+      });
+      return;
+    }
+    seenIds.add(result.entry.id);
+    entries.push(result.entry);
+  });
+  if (entries.length > 0 && hasDependencyCycle(entries)) {
+    errors.push({
+      path: "$",
+      message: "Circular dependsOn relationship detected",
+      code: "circular_dependency"
+    });
+  }
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    if (new Date(entry.showNewUntil).getTime() <= new Date(entry.releasedAt).getTime()) {
+      errors.push({
+        path: `[${index}].showNewUntil`,
+        message: "showNewUntil must be after releasedAt",
+        code: "invalid_value"
+      });
+    }
+    if (entry.url && !isSafeUrl(entry.url)) {
+      errors.push({
+        path: `[${index}].url`,
+        message: "url must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    if (entry.image && !isSafeUrl(entry.image)) {
+      errors.push({
+        path: `[${index}].image`,
+        message: "image must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    if (entry.cta?.url && !isSafeUrl(entry.cta.url)) {
+      errors.push({
+        path: `[${index}].cta.url`,
+        message: "cta.url must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    const unsafeMetaPath = findUnsafeMetaPath(entry.meta);
+    if (unsafeMetaPath) {
+      errors.push({
+        path: `[${index}].${unsafeMetaPath}`,
+        message: `meta contains unsafe key "${unsafeMetaPath.split(".").pop()}"`,
+        code: "invalid_value"
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/changelog-as-code.ts
+function parseScalar(raw) {
+  const value = raw.trim();
+  if (!value) return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(",").map((part) => String(parseScalar(part.trim())));
+  }
+  return value;
+}
+function parseFrontmatter(raw) {
+  const lines = raw.split(/\r?\n/);
+  const root = {};
+  const stack = [
+    { indent: -1, value: root }
+  ];
+  const isArrayContext = (idx) => {
+    for (let i = idx + 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.trim()) continue;
+      const indent = line.length - line.trimStart().length;
+      if (indent <= lines[idx].length - lines[idx].trimStart().length) return false;
+      return line.trimStart().startsWith("- ");
+    }
+    return false;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim() || line.trimStart().startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    const current = stack[stack.length - 1].value;
+    if (trimmed.startsWith("- ")) {
+      if (!Array.isArray(current)) {
+        throw new Error(`Invalid frontmatter list at line ${i + 1}`);
+      }
+      const item = trimmed.slice(2).trim();
+      current.push(parseScalar(item));
+      continue;
+    }
+    const colon = trimmed.indexOf(":");
+    if (colon === -1) {
+      throw new Error(`Invalid frontmatter line ${i + 1}: ${trimmed}`);
+    }
+    const key = trimmed.slice(0, colon).trim();
+    const rest = trimmed.slice(colon + 1).trim();
+    if (Array.isArray(current)) {
+      throw new Error(`Unexpected key in list at line ${i + 1}`);
+    }
+    if (!rest) {
+      const container = isArrayContext(i) ? [] : {};
+      current[key] = container;
+      stack.push({ indent, value: container });
+      continue;
+    }
+    current[key] = parseScalar(rest);
+  }
+  return root;
+}
+function splitFrontmatter(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n");
+  if (!normalized.startsWith("---\n")) {
+    return { frontmatter: {}, body: normalized.trim() };
+  }
+  const end = normalized.indexOf("\n---\n", 4);
+  if (end === -1) {
+    throw new Error("Frontmatter block is not closed with ---");
+  }
+  const fmRaw = normalized.slice(4, end);
+  const body = normalized.slice(end + 5).trim();
+  return {
+    frontmatter: parseFrontmatter(fmRaw),
+    body
+  };
+}
+function asString(value, field, source) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${source}: "${field}" must be a non-empty string`);
+  }
+  return value;
+}
+function asOptionalObject(value, field, source) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${source}: "${field}" must be an object`);
+  }
+  return value;
+}
+function parseFeatureFile(markdown, source = "feature.md") {
+  const { frontmatter, body } = splitFrontmatter(markdown);
+  const entry = {
+    id: asString(frontmatter.id, "id", source),
+    label: asString(frontmatter.label, "label", source),
+    releasedAt: asString(frontmatter.releasedAt, "releasedAt", source),
+    showNewUntil: asString(frontmatter.showNewUntil, "showNewUntil", source),
+    description: body || void 0
+  };
+  if (frontmatter.sidebarKey !== void 0) entry.sidebarKey = asString(frontmatter.sidebarKey, "sidebarKey", source);
+  if (frontmatter.category !== void 0) entry.category = asString(frontmatter.category, "category", source);
+  if (frontmatter.product !== void 0) entry.product = asString(frontmatter.product, "product", source);
+  if (frontmatter.url !== void 0) entry.url = asString(frontmatter.url, "url", source);
+  if (frontmatter.flagKey !== void 0) entry.flagKey = asString(frontmatter.flagKey, "flagKey", source);
+  if (frontmatter.image !== void 0) entry.image = asString(frontmatter.image, "image", source);
+  if (frontmatter.publishAt !== void 0) entry.publishAt = asString(frontmatter.publishAt, "publishAt", source);
+  if (frontmatter.version !== void 0) {
+    if (typeof frontmatter.version === "string" || typeof frontmatter.version === "object") {
+      entry.version = frontmatter.version;
+    } else {
+      throw new Error(`${source}: "version" must be a string or object`);
+    }
+  }
+  if (frontmatter.type !== void 0) {
+    const type = asString(frontmatter.type, "type", source);
+    if (!["feature", "improvement", "fix", "breaking"].includes(type)) {
+      throw new Error(`${source}: invalid "type" value "${type}"`);
+    }
+    entry.type = type;
+  }
+  if (frontmatter.priority !== void 0) {
+    const priority = asString(frontmatter.priority, "priority", source);
+    if (!["critical", "normal", "low"].includes(priority)) {
+      throw new Error(`${source}: invalid "priority" value "${priority}"`);
+    }
+    entry.priority = priority;
+  }
+  const cta = asOptionalObject(frontmatter.cta, "cta", source);
+  if (cta) {
+    entry.cta = {
+      label: asString(cta.label, "cta.label", source),
+      url: asString(cta.url, "cta.url", source)
+    };
+  }
+  const audience = asOptionalObject(frontmatter.audience, "audience", source);
+  if (audience) {
+    const parsedAudience = {};
+    for (const field of ["plan", "role", "region"]) {
+      const value = audience[field];
+      if (value !== void 0) {
+        if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+          throw new Error(`${source}: "audience.${field}" must be string[]`);
+        }
+        parsedAudience[field] = value;
+      }
+    }
+    if (audience.custom !== void 0) {
+      if (!audience.custom || typeof audience.custom !== "object" || Array.isArray(audience.custom)) {
+        throw new Error(`${source}: "audience.custom" must be an object`);
+      }
+      parsedAudience.custom = audience.custom;
+    }
+    entry.audience = parsedAudience;
+  }
+  return entry;
+}
+function normalizePattern(pattern) {
+  const normalized = pattern.replaceAll("\\", "/");
+  if (normalized.endsWith("/**/*.md")) {
+    return {
+      baseDir: normalized.slice(0, -"/**/*.md".length),
+      ext: ".md"
+    };
+  }
+  throw new Error(`Unsupported pattern "${pattern}". Use "features/**/*.md" style patterns.`);
+}
+async function collectFiles(dir, ext) {
+  const out = [];
+  async function walk(current) {
+    let entries;
+    try {
+      entries = await promises.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(ext)) {
+        out.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return out.sort();
+}
+async function buildManifestFromPattern(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const pattern = options.pattern ?? "features/**/*.md";
+  const { baseDir, ext } = normalizePattern(pattern);
+  const baseAbs = path.join(cwd, baseDir);
+  const stats = await promises.stat(baseAbs).catch(() => null);
+  if (!stats || !stats.isDirectory()) {
+    throw new Error(`Pattern base directory does not exist: ${baseDir}`);
+  }
+  const files = await collectFiles(baseAbs, ext);
+  const entries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const content = await promises.readFile(file, "utf8");
+    const source = path.relative(cwd, file).split(path.sep).join("/");
+    const entry = parseFeatureFile(content, source);
+    if (seenIds.has(entry.id)) {
+      throw new Error(`Duplicate feature id "${entry.id}" found at ${source}`);
+    }
+    seenIds.add(entry.id);
+    entries.push(entry);
+  }
+  if (options.outFile) {
+    const outPath = path.join(cwd, options.outFile);
+    await promises.writeFile(outPath, `${JSON.stringify(entries, null, 2)}
+`, "utf8");
+  }
+  return entries;
+}
+
+// src/cms.ts
+var DEFAULT_FIELDS = {
+  id: "id",
+  label: "label",
+  releasedAt: "releasedAt",
+  showNewUntil: "showNewUntil",
+  description: "description",
+  sidebarKey: "sidebarKey",
+  category: "category",
+  product: "product",
+  flagKey: "flagKey",
+  url: "url",
+  image: "image",
+  publishAt: "publishAt",
+  type: "type",
+  priority: "priority",
+  ctaLabel: "cta.label",
+  ctaUrl: "cta.url"
+};
+function getByPath(record, path) {
+  const parts = path.split(".").filter(Boolean);
+  let cursor = record;
+  for (const part of parts) {
+    if (!cursor || typeof cursor !== "object") return void 0;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function normalizeLocalizedValue(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const objectValue = value;
+    const keys = Object.keys(objectValue);
+    if (keys.length === 1) {
+      const nested = objectValue[keys[0]];
+      if (typeof nested === "string" || typeof nested === "number" || typeof nested === "boolean" || nested == null) {
+        return nested;
+      }
+    }
+  }
+  return value;
+}
+function resolveField(record, resolver) {
+  if (!resolver) return void 0;
+  if (typeof resolver === "function") return resolver(record);
+  return normalizeLocalizedValue(getByPath(record, resolver));
+}
+function asString2(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : void 0;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return void 0;
+}
+function normalizeFieldMapping(defaults, overrides) {
+  return {
+    ...defaults,
+    ...overrides
+  };
+}
+function validateMappedEntries(entries, options) {
+  const strictValidation = options?.strictValidation ?? false;
+  const validEntries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const errors = [];
+  for (const entry of entries) {
+    if (seenIds.has(entry.id)) {
+      errors.push(`${entry.id}: duplicate id`);
+      continue;
+    }
+    seenIds.add(entry.id);
+    const validation = validateManifest([entry]);
+    if (validation.valid) {
+      validEntries.push(entry);
+      continue;
+    }
+    const reason = validation.errors.map((error) => `${error.path} ${error.message}`).join("; ");
+    errors.push(`${entry.id}: ${reason}`);
+  }
+  if (errors.length > 0) {
+    if (strictValidation) {
+      throw new Error(`[featuredrop] CMS mapping validation failed: ${errors.join(" | ")}`);
+    }
+    if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+      console.warn(`[featuredrop] Skipped ${errors.length} invalid CMS entries.`);
+    }
+  }
+  return validEntries;
+}
+function mapRecordToFeatureEntry(record, mapping) {
+  const id = asString2(resolveField(record, mapping.id));
+  const label = asString2(resolveField(record, mapping.label));
+  const releasedAt = asString2(resolveField(record, mapping.releasedAt));
+  const showNewUntil = asString2(resolveField(record, mapping.showNewUntil));
+  if (!id || !label || !releasedAt || !showNewUntil) return null;
+  const entry = {
+    id,
+    label,
+    releasedAt,
+    showNewUntil
+  };
+  const description = asString2(resolveField(record, mapping.description));
+  if (description) entry.description = description;
+  const sidebarKey = asString2(resolveField(record, mapping.sidebarKey));
+  if (sidebarKey) entry.sidebarKey = sidebarKey;
+  const category = asString2(resolveField(record, mapping.category));
+  if (category) entry.category = category;
+  const product = asString2(resolveField(record, mapping.product));
+  if (product) entry.product = product;
+  const flagKey = asString2(resolveField(record, mapping.flagKey));
+  if (flagKey) entry.flagKey = flagKey;
+  const url = asString2(resolveField(record, mapping.url));
+  if (url) entry.url = url;
+  const image = asString2(resolveField(record, mapping.image));
+  if (image) entry.image = image;
+  const publishAt = asString2(resolveField(record, mapping.publishAt));
+  if (publishAt) entry.publishAt = publishAt;
+  const type = asString2(resolveField(record, mapping.type));
+  if (type && ["feature", "improvement", "fix", "breaking"].includes(type)) {
+    entry.type = type;
+  }
+  const priority = asString2(resolveField(record, mapping.priority));
+  if (priority && ["critical", "normal", "low"].includes(priority)) {
+    entry.priority = priority;
+  }
+  const ctaLabel = asString2(resolveField(record, mapping.ctaLabel));
+  const ctaUrl = asString2(resolveField(record, mapping.ctaUrl));
+  if (ctaLabel && ctaUrl) {
+    entry.cta = { label: ctaLabel, url: ctaUrl };
+  }
+  return entry;
+}
+async function fetchJson(input, init) {
+  const response = await fetch(input, init);
+  if (!response.ok) {
+    throw new Error(`[featuredrop] CMS request failed (${response.status}) for ${input}`);
+  }
+  return response.json();
+}
+var ContentfulAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async load() {
+    const environment = this.options.environment ?? "master";
+    const params = new URLSearchParams({
+      content_type: this.options.contentType,
+      limit: String(this.options.limit ?? 1e3)
+    });
+    if (this.options.locale) {
+      params.set("locale", this.options.locale);
+    }
+    const url = `https://cdn.contentful.com/spaces/${encodeURIComponent(this.options.spaceId)}/environments/${encodeURIComponent(environment)}/entries?${params.toString()}`;
+    const payload = await fetchJson(url, {
+      headers: {
+        Authorization: `Bearer ${this.options.accessToken}`
+      }
+    });
+    const mapping = normalizeFieldMapping(
+      {
+        ...DEFAULT_FIELDS,
+        id: "sys.id",
+        label: "fields.label",
+        description: "fields.description",
+        releasedAt: "fields.releasedAt",
+        showNewUntil: "fields.showNewUntil",
+        sidebarKey: "fields.sidebarKey",
+        category: "fields.category",
+        product: "fields.product",
+        flagKey: "fields.flagKey",
+        url: "fields.url",
+        image: "fields.image",
+        publishAt: "fields.publishAt",
+        type: "fields.type",
+        priority: "fields.priority",
+        ctaLabel: "fields.ctaLabel",
+        ctaUrl: "fields.ctaUrl"
+      },
+      this.options.fieldMapping
+    );
+    const entries = (payload.items ?? []).map((item) => mapRecordToFeatureEntry(item, mapping)).filter((entry) => entry !== null);
+    return validateMappedEntries(entries, this.options);
+  }
+};
+var SanityAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async load() {
+    const version = this.options.apiVersion ?? "v2023-10-01";
+    const queryParam = encodeURIComponent(this.options.query);
+    const url = `https://${encodeURIComponent(this.options.projectId)}.api.sanity.io/${version}/data/query/${encodeURIComponent(this.options.dataset)}?query=${queryParam}`;
+    const headers = {};
+    if (this.options.token) {
+      headers.Authorization = `Bearer ${this.options.token}`;
+    }
+    const payload = await fetchJson(url, {
+      headers
+    });
+    const mapping = normalizeFieldMapping(
+      {
+        ...DEFAULT_FIELDS,
+        id: "_id"
+      },
+      this.options.fieldMapping
+    );
+    const entries = (payload.result ?? []).map((item) => mapRecordToFeatureEntry(item, mapping)).filter((entry) => entry !== null);
+    return validateMappedEntries(entries, this.options);
+  }
+};
+var StrapiAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async load() {
+    const endpoint = this.options.endpoint ?? "/api/features";
+    const base = this.options.baseUrl.replace(/\/+$/, "");
+    const query = this.options.query ? `?${this.options.query}` : "";
+    const url = `${base}${endpoint}${query}`;
+    const headers = {};
+    if (this.options.token) {
+      headers.Authorization = `Bearer ${this.options.token}`;
+    }
+    const payload = await fetchJson(url, { headers });
+    const mapping = normalizeFieldMapping(DEFAULT_FIELDS, this.options.fieldMapping);
+    const entries = (payload.data ?? []).map((item) => {
+      if (!item || typeof item !== "object") return null;
+      const record = item;
+      const attributes = record.attributes;
+      if (attributes && typeof attributes === "object") {
+        return mapRecordToFeatureEntry(
+          { id: record.id, ...attributes },
+          mapping
+        );
+      }
+      return mapRecordToFeatureEntry(record, mapping);
+    }).filter((entry) => entry !== null);
+    return validateMappedEntries(entries, this.options);
+  }
+};
+function notionPropertyToValue(property) {
+  if (!property || typeof property !== "object") return void 0;
+  const typed = property;
+  const type = typed.type;
+  if (typeof type !== "string") return void 0;
+  const value = typed[type];
+  if (type === "title" || type === "rich_text") {
+    if (!Array.isArray(value)) return void 0;
+    return value.map((item) => {
+      if (!item || typeof item !== "object") return "";
+      return asString2(item.plain_text) ?? "";
+    }).join("").trim();
+  }
+  if (type === "select") {
+    if (!value || typeof value !== "object") return void 0;
+    return asString2(value.name);
+  }
+  if (type === "multi_select") {
+    if (!Array.isArray(value)) return void 0;
+    return value.map((item) => item && typeof item === "object" ? asString2(item.name) : void 0).filter((item) => Boolean(item));
+  }
+  if (type === "date") {
+    if (!value || typeof value !== "object") return void 0;
+    return asString2(value.start);
+  }
+  if (type === "number" || type === "url" || type === "email" || type === "phone_number") {
+    return value;
+  }
+  if (type === "checkbox") {
+    return value === true ? "true" : value === false ? "false" : void 0;
+  }
+  return void 0;
+}
+function flattenNotionPage(page) {
+  if (!page || typeof page !== "object") return {};
+  const record = page;
+  const properties = record.properties;
+  const flattened = {
+    id: record.id
+  };
+  if (properties && typeof properties === "object") {
+    Object.entries(properties).forEach(([key, value]) => {
+      flattened[key] = notionPropertyToValue(value);
+    });
+  }
+  return flattened;
+}
+var NotionAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async load() {
+    const body = {};
+    if (this.options.filter) body.filter = this.options.filter;
+    if (this.options.sorts) body.sorts = this.options.sorts;
+    const payload = await fetchJson(
+      `https://api.notion.com/v1/databases/${encodeURIComponent(this.options.databaseId)}/query`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.options.token}`,
+          "Notion-Version": this.options.notionVersion ?? "2022-06-28"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    const mapping = normalizeFieldMapping(DEFAULT_FIELDS, this.options.fieldMapping);
+    const entries = (payload.results ?? []).map((page) => mapRecordToFeatureEntry(flattenNotionPage(page), mapping)).filter((entry) => entry !== null);
+    return validateMappedEntries(entries, this.options);
+  }
+};
+var MarkdownAdapter = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async load() {
+    if (this.options.pattern) {
+      const entries2 = await buildManifestFromPattern({
+        cwd: this.options.cwd,
+        pattern: this.options.pattern
+      });
+      return validateMappedEntries(entries2, this.options);
+    }
+    const entries = this.options.entries ?? [];
+    const mapped = entries.map((entry, index) => {
+      const source = entry.source ?? `feature-${index + 1}.md`;
+      return parseFeatureFile(entry.markdown, source);
+    });
+    return validateMappedEntries(mapped, this.options);
+  }
+};
+
+exports.ContentfulAdapter = ContentfulAdapter;
+exports.MarkdownAdapter = MarkdownAdapter;
+exports.NotionAdapter = NotionAdapter;
+exports.SanityAdapter = SanityAdapter;
+exports.StrapiAdapter = StrapiAdapter;
+//# sourceMappingURL=cms.cjs.map
+//# sourceMappingURL=cms.cjs.map