@replohq/sdk 0.13.0 → 0.15.0

package/chunk-GV5FY7ZZ.mjs

@@ -0,0 +1,89 @@
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js
+var Symbol = root_default.Symbol;
+var Symbol_default = Symbol;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isNumber.js
+var numberTag = "[object Number]";
+function isNumber(value) {
+  return typeof value == "number" || isObjectLike_default(value) && baseGetTag_default(value) == numberTag;
+}
+var isNumber_default = isNumber;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isString.js
+var stringTag = "[object String]";
+function isString(value) {
+  return typeof value == "string" || !isArray_default(value) && isObjectLike_default(value) && baseGetTag_default(value) == stringTag;
+}
+var isString_default = isString;
+
+export { Symbol_default, baseGetTag_default, freeGlobal_default, isArray_default, isNumber_default, isObjectLike_default, isObject_default, isString_default, root_default };

package/chunk-I23U2PUI.mjs

@@ -0,0 +1,151 @@
+import { CONTENT_SEO_VALUE_KEYS, CONTENT_RELATED_VALUE_STORAGE_KEY, CONTENT_PRIVATE_VALUE_KEYS, contentEntryStatusSchema, isContentPrivateValueKey, getContentFieldValueSchema } from './chunk-IQ5GRTXO.mjs';
+import { stringify, parseDocument } from 'yaml';
+import { z } from 'zod';
+
+var frontmatterDataSchema = z.record(z.string(), z.unknown());
+var CONTENT_FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/u;
+function parseContentFrontmatterYaml(yamlText) {
+  try {
+    const document = parseDocument(yamlText, {
+      merge: false,
+      schema: "core",
+      strict: true,
+      uniqueKeys: true
+    });
+    if (document.errors.length > 0) {
+      return null;
+    }
+    const parsed = frontmatterDataSchema.safeParse(
+      document.toJS({ maxAliasCount: 20 })
+    );
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function parseContentFrontmatter(raw) {
+  const match = raw.match(CONTENT_FRONTMATTER_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const values = parseContentFrontmatterYaml(match[1] ?? "");
+  if (values === null) {
+    return null;
+  }
+  return {
+    values,
+    body: raw.slice(match[0].length).replace(/^\r?\n/u, "")
+  };
+}
+var CONTENT_MANAGED_ENTRY_VALUE_KEYS = [
+  "slug",
+  "title",
+  "status",
+  "author",
+  "authorInitials",
+  "excerpt",
+  "coverImage",
+  "coverImageAlt",
+  "tags",
+  "updatedAt",
+  "publishedAt",
+  "archivedAt",
+  ...CONTENT_SEO_VALUE_KEYS,
+  CONTENT_RELATED_VALUE_STORAGE_KEY,
+  ...CONTENT_PRIVATE_VALUE_KEYS
+];
+var contentEntryFrontmatterSchema = z.object({
+  slug: z.unknown().optional(),
+  title: z.string().nullish(),
+  status: contentEntryStatusSchema,
+  author: z.string().nullish(),
+  authorInitials: z.string().nullish(),
+  excerpt: z.string().nullish(),
+  coverImage: z.string().nullish(),
+  coverImageAlt: z.string().nullish(),
+  tags: z.array(z.string()).nullish(),
+  updatedAt: z.string().nullish(),
+  publishedAt: z.string().nullish(),
+  archivedAt: z.string().nullish(),
+  seoTitle: z.string().nullish(),
+  seoDescription: z.string().nullish(),
+  related: z.array(z.string()).nullish(),
+  scratchpad: z.unknown().optional(),
+  backlinks: z.unknown().optional()
+}).passthrough();
+function parseContentEntryDocument(raw) {
+  const frontmatter = parseContentFrontmatter(raw);
+  if (!frontmatter) {
+    return {
+      status: "invalid",
+      message: "Entry frontmatter is missing or contains invalid YAML."
+    };
+  }
+  const parsedValues = contentEntryFrontmatterSchema.safeParse(
+    frontmatter.values
+  );
+  if (!parsedValues.success) {
+    const issue = parsedValues.error.issues[0];
+    const field = issue?.path.join(".");
+    return {
+      status: "invalid",
+      message: `${field ? `Invalid ${field}: ` : ""}${issue?.message ?? "Invalid entry fields."}`
+    };
+  }
+  return {
+    status: "ready",
+    document: {
+      values: parsedValues.data,
+      body: frontmatter.body
+    }
+  };
+}
+function serializeContentEntryDocument({
+  values,
+  body
+}) {
+  const yamlText = stringify(values).replace(/\n+$/u, "");
+  const normalizedBody = `${body.replace(/\s+$/u, "")}
+`;
+  return `---
+${yamlText}
+---
+
+${normalizedBody}`;
+}
+function getContentRenderableEntryValues({
+  document,
+  slug
+}) {
+  const publicFrontmatterValues = Object.fromEntries(
+    Object.entries(document.values).filter(([fieldId]) => {
+      return !isContentPrivateValueKey(fieldId);
+    })
+  );
+  return {
+    ...publicFrontmatterValues,
+    relatedContent: publicFrontmatterValues[CONTENT_RELATED_VALUE_STORAGE_KEY] ?? [],
+    body: document.body,
+    slug
+  };
+}
+function getContentEntryFieldValidationIssues({
+  fields,
+  values,
+  requireRequiredFields
+}) {
+  return fields.flatMap((field) => {
+    if (!field.enabled || isContentPrivateValueKey(field.id)) {
+      return [];
+    }
+    const value = values[field.id];
+    const isMissing = value === void 0 || value === null || value === "";
+    if (isMissing) {
+      return requireRequiredFields && field.required ? [{ fieldId: field.id, message: "Required value is missing." }] : [];
+    }
+    const parsedValue = getContentFieldValueSchema(field.type).safeParse(value);
+    return parsedValue.success ? [] : [{ fieldId: field.id, message: "Value has the wrong format." }];
+  });
+}
+
+export { CONTENT_MANAGED_ENTRY_VALUE_KEYS, contentEntryFrontmatterSchema, getContentEntryFieldValidationIssues, getContentRenderableEntryValues, parseContentEntryDocument, serializeContentEntryDocument };

package/chunk-IQ5GRTXO.mjs

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+
+// ../schemas/contentCollection.ts
+var CONTENT_MANIFEST_FILENAME = "content-manifest.generated.json";
+var CONTENT_DIRNAME = "content";
+var CONTENT_COLLECTION_SCHEMA_FILENAME = "_collection.json";
+var CONTENT_ENTRY_FILE_EXTENSION = ".mdx";
+var CONTENT_RELATED_VALUE_STORAGE_KEY = "related";
+var CONTENT_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var CONTENT_MAX_SLUG_LENGTH = 100;
+var contentSlugSchema = z.string().min(1).max(CONTENT_MAX_SLUG_LENGTH).regex(CONTENT_SLUG_PATTERN);
+function isValidContentSlug(slug) {
+  return contentSlugSchema.safeParse(slug).success;
+}
+var CONTENT_ENTRY_STATUSES = [
+  "draft",
+  "published",
+  "archived"
+];
+var contentEntryStatusSchema = z.enum(CONTENT_ENTRY_STATUSES);
+function isContentEntryPubliclyVisible({
+  status,
+  archivedAt,
+  allowDrafts
+}) {
+  if (archivedAt !== null && archivedAt !== void 0) {
+    return false;
+  }
+  return status === "published" || allowDrafts && status === "draft";
+}
+var contentCollectionFieldTypeSchema = z.enum([
+  "short-text",
+  "long-text",
+  "rich-text",
+  "image",
+  "tags",
+  "related",
+  "date",
+  "url",
+  "status",
+  "boolean"
+]);
+var contentCollectionColorSchema = z.enum([
+  "seashell",
+  "yellow",
+  "lightGreen",
+  "darkGreen",
+  "lightPink",
+  "magenta",
+  "purple",
+  "blue"
+]);
+var contentCollectionFieldSchema = z.object({
+  id: z.string().min(1).max(128),
+  label: z.string().min(1).max(200),
+  type: contentCollectionFieldTypeSchema,
+  required: z.boolean(),
+  enabled: z.boolean(),
+  helpText: z.string().optional(),
+  builtin: z.boolean()
+});
+var contentCollectionFileSchema = z.object({
+  name: z.string().min(1).max(200),
+  description: z.string(),
+  icon: z.string().min(1),
+  color: contentCollectionColorSchema,
+  tags: z.array(z.string()),
+  fields: z.array(contentCollectionFieldSchema).max(200),
+  archivedAt: z.iso.datetime().nullish(),
+  hasListingPage: z.boolean().optional()
+}).passthrough();
+function isSafeContentUrl(value, { image }) {
+  try {
+    const url = new URL(value, "https://content.local");
+    return image ? url.protocol === "http:" || url.protocol === "https:" : ["http:", "https:", "mailto:", "tel:"].includes(url.protocol);
+  } catch {
+    return false;
+  }
+}
+function getContentFieldValueSchema(fieldType) {
+  if (fieldType === "short-text" || fieldType === "long-text" || fieldType === "rich-text") {
+    return z.string();
+  }
+  if (fieldType === "image") {
+    return z.string().refine((value) => isSafeContentUrl(value, { image: true }));
+  }
+  if (fieldType === "tags" || fieldType === "related") {
+    return z.array(z.string());
+  }
+  if (fieldType === "date") {
+    return z.string().refine((value) => !Number.isNaN(Date.parse(value)));
+  }
+  if (fieldType === "url") {
+    return z.string().refine((value) => isSafeContentUrl(value, { image: false }));
+  }
+  if (fieldType === "status") {
+    return contentEntryStatusSchema;
+  }
+  return z.boolean();
+}
+var CONTENT_RESERVED_COLLECTION_SLUGS = ["api", "new"];
+var CONTENT_RESERVED_ENTRY_SLUGS = ["new"];
+var reservedEntrySlugSet = new Set(
+  CONTENT_RESERVED_ENTRY_SLUGS
+);
+function isContentReservedEntrySlug(slug) {
+  return reservedEntrySlugSet.has(slug);
+}
+var CONTENT_BUILTIN_FIELD_ROLES = {
+  title: "content",
+  author: "content",
+  excerpt: "content",
+  coverImage: "content",
+  body: "content",
+  tags: "content",
+  relatedContent: "content",
+  slug: "publishing",
+  status: "publishing",
+  publishedAt: "publishing"
+};
+var CONTENT_SEO_VALUE_KEYS = ["seoTitle", "seoDescription"];
+var CONTENT_PRIVATE_VALUE_KEYS = ["scratchpad", "backlinks"];
+var CONTENT_COUPLED_VALUE_PARENTS = {
+  coverImageAlt: "coverImage",
+  authorInitials: "author"
+};
+var privateValueKeySet = new Set(
+  CONTENT_PRIVATE_VALUE_KEYS
+);
+var seoValueKeySet = new Set(CONTENT_SEO_VALUE_KEYS);
+var reservedCollectionSlugSet = new Set(
+  CONTENT_RESERVED_COLLECTION_SLUGS
+);
+function formatContentEntryRef({
+  collectionSlug,
+  entrySlug
+}) {
+  return `${collectionSlug}/${entrySlug}`;
+}
+function parseContentEntryRef(ref) {
+  const normalized = ref.replace(/^content\//u, "").replace(/\.mdx$/u, "");
+  const segments = normalized.split("/");
+  if (segments.length !== 2) {
+    return null;
+  }
+  const [collectionSlug, entrySlug] = segments;
+  if (!collectionSlug || !entrySlug) {
+    return null;
+  }
+  return { collectionSlug, entrySlug };
+}
+function isContentPrivateValueKey(key) {
+  return privateValueKeySet.has(key);
+}
+function isContentSeoValueKey(key) {
+  return seoValueKeySet.has(key);
+}
+function isContentReservedCollectionSlug(slug) {
+  return reservedCollectionSlugSet.has(slug);
+}
+function getContentFieldRole(fieldId) {
+  if (isContentSeoValueKey(fieldId)) {
+    return "seo";
+  }
+  if (isContentPrivateValueKey(fieldId)) {
+    return "private";
+  }
+  const builtinRoles = CONTENT_BUILTIN_FIELD_ROLES;
+  return builtinRoles[fieldId] ?? "content";
+}
+function getPublishedContentFields(fields) {
+  return fields.filter((field) => {
+    return field.enabled && getContentFieldRole(field.id) !== "private";
+  });
+}
+function getOrderedContentFields(fields) {
+  return fields.filter((field) => {
+    return field.enabled && getContentFieldRole(field.id) === "content";
+  });
+}
+
+export { CONTENT_BUILTIN_FIELD_ROLES, CONTENT_COLLECTION_SCHEMA_FILENAME, CONTENT_COUPLED_VALUE_PARENTS, CONTENT_DIRNAME, CONTENT_ENTRY_FILE_EXTENSION, CONTENT_ENTRY_STATUSES, CONTENT_MANIFEST_FILENAME, CONTENT_MAX_SLUG_LENGTH, CONTENT_PRIVATE_VALUE_KEYS, CONTENT_RELATED_VALUE_STORAGE_KEY, CONTENT_RESERVED_COLLECTION_SLUGS, CONTENT_RESERVED_ENTRY_SLUGS, CONTENT_SEO_VALUE_KEYS, CONTENT_SLUG_PATTERN, contentCollectionColorSchema, contentCollectionFieldSchema, contentCollectionFieldTypeSchema, contentCollectionFileSchema, contentEntryStatusSchema, contentSlugSchema, formatContentEntryRef, getContentFieldRole, getContentFieldValueSchema, getOrderedContentFields, getPublishedContentFields, isContentEntryPubliclyVisible, isContentPrivateValueKey, isContentReservedCollectionSlug, isContentReservedEntrySlug, isContentSeoValueKey, isSafeContentUrl, isValidContentSlug, parseContentEntryRef };

package/chunk-VKO7P3ED.mjs

@@ -0,0 +1,41 @@
+// ../replo-utils/lib/object.ts
+function omit(obj, keysToOmit) {
+  const result = { ...obj };
+  for (const key of keysToOmit) {
+    delete result[key];
+  }
+  return result;
+}
+
+// ../replo-utils/lib/json.ts
+function parseJsonOrNull(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+function omitJsonObjectFieldsOrNull({
+  json,
+  fields
+}) {
+  const parsedJson = parseJsonOrNull(json);
+  if (typeof parsedJson !== "object" || parsedJson === null || Array.isArray(parsedJson)) {
+    return null;
+  }
+  return jsonStringifyOrNull(
+    omit(Object.fromEntries(Object.entries(parsedJson)), fields)
+  );
+}
+function jsonStringifyOrNull(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}
+
+export { jsonStringifyOrNull, omitJsonObjectFieldsOrNull, parseJsonOrNull };

package/content.d.ts

@@ -0,0 +1,126 @@
+import "server-only";
+import type { Metadata } from "next";
+import type { ReactNode } from "react";
+import type { ContentManifest } from "./_vendor/schemas/contentManifest";
+import { contentCollectionFieldSchema } from "./_vendor/schemas/contentCollection";
+import { z } from "zod";
+/** Public name for the shared collection-field contract. */
+export type ContentField = z.infer<typeof contentCollectionFieldSchema>;
+export interface ContentEntry {
+    collection: {
+        name: string;
+        description: string;
+        slug: string;
+    };
+    fields: ContentField[];
+    slug: string;
+    body: string;
+    values: Record<string, unknown>;
+}
+/** One entry's slot in a collection listing. */
+export interface ContentCollectionEntry {
+    slug: string;
+    title: string;
+    excerpt: string | null;
+    coverImage: string | null;
+    coverImageAlt: string | null;
+    publishedAt: string | null;
+    status: "draft" | "published";
+}
+export interface ContentCollection {
+    slug: string;
+    name: string;
+    description: string;
+    entries: ContentCollectionEntry[];
+}
+/** An ordered content field paired with this entry's value for it. */
+export interface ContentFieldWithValue {
+    field: ContentField;
+    value: unknown;
+}
+export interface ContentSitemapEntry {
+    url: string;
+    lastModified?: Date;
+}
+export interface ContentSource {
+    read(relativePath: string): Promise<string | null>;
+    listCollections(): Promise<string[]>;
+    listEntries(collection: string): Promise<string[]>;
+}
+interface ContentOptions {
+    contentSource?: ContentSource;
+    contentDirectory?: string;
+    contentManifest?: ContentManifest;
+}
+export declare function createContentSource({ contentDirectory, contentManifest, }?: {
+    contentDirectory?: string;
+    contentManifest?: ContentManifest;
+}): ContentSource;
+export declare function getContentEntry({ collection, slug, ...contentOptions }: {
+    collection: string;
+    slug: string;
+} & ContentOptions): Promise<ContentEntry>;
+/** Static params for one collection's `[slug]` detail route. */
+export declare function getContentCollectionStaticParams({ collection, ...contentOptions }: {
+    collection: string;
+} & ContentOptions): Promise<{
+    slug: string;
+}[]>;
+/**
+ * A collection and its renderable entries for a listing page. Uses the
+ * not-found contract when the collection is missing or archived.
+ */
+export declare function getContentCollection({ collection, ...contentOptions }: {
+    collection: string;
+} & ContentOptions): Promise<ContentCollection>;
+/**
+ * Per-entry head metadata (title/description/OpenGraph/Twitter) from the
+ * entry's SEO fields with content fallbacks. Returns an empty object when the
+ * entry is not renderable, so `generateMetadata` can call it unconditionally.
+ */
+export declare function getContentEntryMetadata({ collection, slug, ...contentOptions }: {
+    collection: string;
+    slug: string;
+} & ContentOptions): Promise<Metadata>;
+/**
+ * Structured data for an entry as a JSON-LD script tag. Serialization is
+ * script-safe (`<` escaped) so entry content can never break out of the tag.
+ * The type is a deliberately neutral `WebPage`; collections have no schema
+ * type of their own.
+ */
+export declare function ContentEntryJsonLd({ entry }: {
+    entry: ContentEntry;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Absolute sitemap entries for every collection listing and renderable entry.
+ * `origin` comes from the caller (e.g. the request's platform-validated Host)
+ * because site origins are not fixed at build time.
+ */
+export declare function getContentSitemapEntries({ origin, ...contentOptions }: {
+    origin: string;
+} & ContentOptions): Promise<ContentSitemapEntry[]>;
+/**
+ * The full sitemap XML document for a site's content (home, collection
+ * listings, entries). Kept here so the generated sitemap route stays a tiny,
+ * restylable-free shell around one call.
+ */
+export declare function getContentSitemapXml({ origin, ...contentOptions }: {
+    origin: string;
+} & ContentOptions): Promise<string>;
+/**
+ * The entry's renderable content fields in collection-settings order, paired
+ * with values. This is the published half of the shared ordering contract in
+ * `schemas/contentCollection`; empty values are omitted so templates never render
+ * bare labels.
+ */
+export declare function getContentFields(entry: ContentEntry): ContentFieldWithValue[];
+export declare function ContentFieldValue({ field, value, }: {
+    field: ContentField;
+    value: unknown;
+}): ReactNode;
+/** A related entry resolved to a public link; unresolvable refs stay plain text. */
+export interface ContentRelatedLink {
+    title: string;
+    href: string;
+}
+export {};