nextjs-studio 0.4.0 → 1.0.0

package/dist/core/server.js

@@ -0,0 +1,707 @@
+// src/core/server.ts
+import path3 from "path";
+
+// src/shared/constants.ts
+var CONTENTS_DIR = "contents";
+var CONFIG_FILENAMES = ["studio.config.ts", "studio.config.js", "studio.config.mjs"];
+var SUPPORTED_EXTENSIONS = [".mdx", ".json"];
+var COLLECTION_ORDER_FILE = "collection.json";
+var IMAGE_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "image/avif"
+];
+var VIDEO_MIME_TYPES = ["video/mp4", "video/webm", "video/ogg"];
+var AUDIO_MIME_TYPES = [
+  "audio/mpeg",
+  "audio/ogg",
+  "audio/wav",
+  "audio/webm",
+  "audio/aac",
+  "audio/flac"
+];
+var MEDIA_MIME_TYPES = [...IMAGE_MIME_TYPES, ...VIDEO_MIME_TYPES, ...AUDIO_MIME_TYPES];
+
+// src/core/fs-adapter.ts
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+var FsAdapter = class {
+  basePath;
+  constructor(basePath) {
+    this.basePath = path.resolve(basePath);
+  }
+  resolve(...segments) {
+    return path.resolve(this.basePath, ...segments);
+  }
+  async readFile(filePath) {
+    return fs.readFile(this.resolve(filePath), "utf-8");
+  }
+  async writeFile(filePath, content) {
+    const fullPath = this.resolve(filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content, "utf-8");
+  }
+  async deleteFile(filePath) {
+    await fs.unlink(this.resolve(filePath));
+  }
+  async exists(filePath) {
+    try {
+      await fs.access(this.resolve(filePath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getStats(filePath) {
+    const fullPath = this.resolve(filePath);
+    const stats = await fs.stat(fullPath);
+    return { path: filePath, size: stats.size, modifiedAt: stats.mtime };
+  }
+  async listFiles(dirPath, extensions) {
+    const fullPath = this.resolve(dirPath);
+    const filterExts = extensions ?? SUPPORTED_EXTENSIONS;
+    let entries;
+    try {
+      entries = await fs.readdir(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isFile() && filterExts.some((ext) => entry.name.endsWith(ext))).map((entry) => this.join(dirPath, entry.name));
+  }
+  async listDirectories(dirPath) {
+    const fullPath = this.resolve(dirPath);
+    let entries;
+    try {
+      entries = await fs.readdir(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => this.join(dirPath, entry.name));
+  }
+  async readBuffer(filePath) {
+    return fs.readFile(this.resolve(filePath));
+  }
+  async writeBuffer(filePath, data) {
+    const fullPath = this.resolve(filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, data);
+  }
+  async listAllFiles(dirPath) {
+    const fullPath = this.resolve(dirPath);
+    let entries;
+    try {
+      entries = await fs.readdir(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const relativePath = this.join(dirPath, entry.name);
+      const stats = await fs.stat(this.resolve(relativePath));
+      results.push({ name: entry.name, relativePath, size: stats.size, modifiedAt: stats.mtime });
+    }
+    return results;
+  }
+  join(...segments) {
+    return path.join(...segments);
+  }
+  basename(filePath) {
+    return path.basename(filePath);
+  }
+  extname(filePath) {
+    return path.extname(filePath);
+  }
+  relative(from, to) {
+    return path.relative(from, to);
+  }
+  normalizeSlug(relativePath, ext) {
+    return relativePath.replace(ext, "").split(path.sep).join("/");
+  }
+  readFileSync(filePath) {
+    return fsSync.readFileSync(this.resolve(filePath), "utf-8");
+  }
+  existsSync(filePath) {
+    return fsSync.existsSync(this.resolve(filePath));
+  }
+  listFilesSync(dirPath, extensions) {
+    const fullPath = this.resolve(dirPath);
+    const filterExts = extensions ?? SUPPORTED_EXTENSIONS;
+    let entries;
+    try {
+      entries = fsSync.readdirSync(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isFile() && filterExts.some((ext) => entry.name.endsWith(ext))).map((entry) => this.join(dirPath, entry.name));
+  }
+  listDirectoriesSync(dirPath) {
+    const fullPath = this.resolve(dirPath);
+    let entries;
+    try {
+      entries = fsSync.readdirSync(fullPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => this.join(dirPath, entry.name));
+  }
+};
+
+// src/core/indexer.ts
+import slugify from "@sindresorhus/slugify";
+
+// src/core/parsers/parser-mdx.ts
+import matter from "gray-matter";
+
+// src/core/frontmatter-binder.ts
+var TOKEN_REGEX = /\{frontmatter\.([a-zA-Z0-9_.]+)\}/g;
+function bindFrontmatter(body, data) {
+  return body.replace(TOKEN_REGEX, (_match, path4) => {
+    const value = resolvePath(data, path4);
+    if (value === void 0 || value === null) return _match;
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  });
+}
+function resolvePath(obj, path4) {
+  const keys = path4.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+
+// src/core/parsers/parser-mdx.ts
+function normalizeDates(data) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (value instanceof Date) {
+      result[key] = value.toISOString().split("T")[0];
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = normalizeDates(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseMdx(content, options) {
+  const { data: rawData, content: body } = matter(content);
+  const data = normalizeDates(rawData);
+  const trimmed = body.trim();
+  return {
+    data,
+    body: options?.bindTokens ? bindFrontmatter(trimmed, data) : trimmed
+  };
+}
+
+// src/core/parsers/parser-json.ts
+function parseJson(content) {
+  const parsed = JSON.parse(content);
+  if (Array.isArray(parsed)) {
+    return {
+      type: "json-array",
+      entries: parsed
+    };
+  }
+  if (typeof parsed === "object" && parsed !== null) {
+    return {
+      type: "json-object",
+      data: parsed
+    };
+  }
+  throw new Error("JSON content must be an array or object");
+}
+
+// src/core/schema-inferrer.ts
+var RE_ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var RE_ISO_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?$/;
+var RE_EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var RE_URL = /^https?:\/\/.+/;
+var LONG_TEXT_THRESHOLD = 200;
+var RICH_TEXT_FIELD_NAMES = ["description", "descriptions", "text", "content"];
+function isISODate(value) {
+  return RE_ISO_DATE.test(value);
+}
+function isISODateTime(value) {
+  return RE_ISO_DATETIME.test(value);
+}
+function isEmail(value) {
+  return RE_EMAIL.test(value);
+}
+function isUrl(value) {
+  return RE_URL.test(value);
+}
+function inferStringField(name, strings) {
+  if (strings.every(isEmail)) return { name, type: "email" };
+  if (strings.every(isUrl)) return { name, type: "url" };
+  if (strings.every(isISODateTime)) return { name, type: "date", includeTime: true };
+  if (strings.every(isISODate)) return { name, type: "date" };
+  if (RICH_TEXT_FIELD_NAMES.includes(name.toLowerCase())) return { name, type: "long-text" };
+  const isLong = strings.some((s) => s.length > LONG_TEXT_THRESHOLD || s.includes("\n"));
+  return { name, type: isLong ? "long-text" : "text" };
+}
+function inferArrayField(name, items) {
+  if (items.length === 0) return { name, type: "array", itemFields: [] };
+  if (items.every((item) => typeof item === "string")) {
+    const unique = [...new Set(items)].slice(0, 50);
+    const options = unique.map((v) => ({ label: v, value: v }));
+    return { name, type: "multi-select", options };
+  }
+  if (items.every((item) => typeof item === "object" && item !== null && !Array.isArray(item))) {
+    return { name, type: "array", itemFields: inferFields(items) };
+  }
+  return { name, type: "array", itemFields: [] };
+}
+function inferFieldDefinition(name, values) {
+  const present = values.filter((v) => v !== null && v !== void 0);
+  if (present.length === 0) return { name, type: "text" };
+  if (present.every((v) => typeof v === "boolean")) return { name, type: "boolean" };
+  if (present.every((v) => typeof v === "number")) {
+    const format = present.every((v) => Number.isInteger(v)) ? "integer" : "decimal";
+    return { name, type: "number", format };
+  }
+  if (present.every((v) => typeof v === "string")) {
+    return inferStringField(name, present);
+  }
+  if (present.every((v) => Array.isArray(v))) {
+    return inferArrayField(name, present.flat());
+  }
+  if (present.every((v) => typeof v === "object" && v !== null && !Array.isArray(v))) {
+    return { name, type: "object", fields: inferFields(present) };
+  }
+  return { name, type: "text" };
+}
+function inferFields(rows) {
+  const keySet = new Set(rows.flatMap((row) => Object.keys(row)));
+  return Array.from(keySet).map((key) => inferFieldDefinition(key, rows.map((row) => row[key])));
+}
+function inferSchema(entries, collectionName) {
+  const rows = entries.map((entry) => entry.data);
+  return { collection: collectionName, fields: inferFields(rows) };
+}
+
+// src/core/locale-parser.ts
+var LOCALE_REGEX = /\.([a-z]{2}(?:-[A-Z]{2})?)\.mdx$/;
+function parseLocaleFromFilename(filename) {
+  const match = LOCALE_REGEX.exec(filename);
+  return match?.[1];
+}
+function stripLocaleFromSlug(slug, locale) {
+  if (!locale) return slug;
+  const dotSuffix = `.${locale}`;
+  if (slug.endsWith(dotSuffix)) return slug.slice(0, -dotSuffix.length);
+  const dashSuffix = `-${locale}`;
+  if (slug.endsWith(dashSuffix)) return slug.slice(0, -dashSuffix.length);
+  return slug;
+}
+
+// src/core/indexer.ts
+var ContentIndex = class {
+  entries = /* @__PURE__ */ new Map();
+  collections = /* @__PURE__ */ new Map();
+  fs;
+  constructor(fsAdapter) {
+    this.fs = fsAdapter;
+  }
+  async build(config) {
+    this.clear();
+    const dirs = await this.fs.listDirectories(".");
+    for (const dir of dirs) {
+      const dirName = this.fs.basename(dir);
+      const collectionName = slugify(dirName);
+      const collectionConfig = config?.collections?.[collectionName];
+      await this.indexCollection(dirName, collectionName, collectionConfig?.schema);
+    }
+  }
+  buildSync(config) {
+    this.clear();
+    const dirs = this.fs.listDirectoriesSync(".");
+    for (const dir of dirs) {
+      const dirName = this.fs.basename(dir);
+      const collectionName = slugify(dirName);
+      const collectionConfig = config?.collections?.[collectionName];
+      this.indexCollectionSync(dirName, collectionName, collectionConfig?.schema);
+    }
+  }
+  getCollection(name) {
+    return this.entries.get(name) ?? [];
+  }
+  getCollections() {
+    return Array.from(this.collections.values());
+  }
+  clear() {
+    this.entries.clear();
+    this.collections.clear();
+  }
+  updateEntry(collectionName, entry) {
+    const entries = this.entries.get(collectionName) ?? [];
+    const idx = entries.findIndex((e) => e.slug === entry.slug);
+    if (idx >= 0) {
+      entries[idx] = entry;
+    } else {
+      entries.push(entry);
+    }
+    this.entries.set(collectionName, entries);
+    this.updateCollectionMeta(collectionName);
+  }
+  removeEntry(collectionName, slug) {
+    const entries = this.entries.get(collectionName);
+    if (!entries) return;
+    const filtered = entries.filter((e) => e.slug !== slug);
+    this.entries.set(collectionName, filtered);
+    this.updateCollectionMeta(collectionName);
+  }
+  updateCollectionMeta(collectionName) {
+    const col = this.collections.get(collectionName);
+    const entries = this.entries.get(collectionName) ?? [];
+    if (col) {
+      this.collections.set(collectionName, {
+        ...col,
+        count: entries.length,
+        type: this.detectCollectionType(entries)
+      });
+    }
+  }
+  async indexCollection(dirName, collectionName, manualSchema) {
+    const entries = [];
+    await this.scanDir(dirName, collectionName, dirName, entries);
+    const orderPath = this.fs.join(dirName, COLLECTION_ORDER_FILE);
+    const ordering = await this.readOrdering(orderPath);
+    if (ordering) {
+      this.applyOrdering(entries, ordering);
+    }
+    const schema = manualSchema ?? inferSchema(entries, collectionName);
+    this.entries.set(collectionName, entries);
+    this.collections.set(collectionName, {
+      name: collectionName,
+      type: this.detectCollectionType(entries),
+      count: entries.length,
+      basePath: dirName,
+      schema
+    });
+  }
+  indexCollectionSync(dirName, collectionName, manualSchema) {
+    const entries = [];
+    this.scanDirSync(dirName, collectionName, dirName, entries);
+    const orderPath = this.fs.join(dirName, COLLECTION_ORDER_FILE);
+    const ordering = this.readOrderingSync(orderPath);
+    if (ordering) {
+      this.applyOrdering(entries, ordering);
+    }
+    const schema = manualSchema ?? inferSchema(entries, collectionName);
+    this.entries.set(collectionName, entries);
+    this.collections.set(collectionName, {
+      name: collectionName,
+      type: this.detectCollectionType(entries),
+      count: entries.length,
+      basePath: dirName,
+      schema
+    });
+  }
+  async scanDir(dirName, collectionName, dirPath, entries) {
+    const subDirs = await this.fs.listDirectories(dirPath);
+    for (const subDir of subDirs) {
+      await this.scanDir(dirName, collectionName, subDir, entries);
+    }
+    const files = await this.fs.listFiles(dirPath);
+    for (const filePath of files) {
+      const fileName = this.fs.basename(filePath);
+      if (fileName === COLLECTION_ORDER_FILE) continue;
+      const ext = this.fs.extname(fileName);
+      const content = await this.fs.readFile(filePath);
+      const relativePath = this.fs.relative(dirName, filePath);
+      const slug = this.fs.normalizeSlug(relativePath, ext).split("/").map((segment) => slugify(segment)).join("/");
+      if (ext === ".mdx") {
+        entries.push(this.buildMdxEntry(collectionName, slug, fileName, content));
+      } else if (ext === ".json") {
+        entries.push(...this.buildJsonEntries(collectionName, slug, content));
+      }
+    }
+  }
+  scanDirSync(dirName, collectionName, dirPath, entries) {
+    const subDirs = this.fs.listDirectoriesSync(dirPath);
+    for (const subDir of subDirs) {
+      this.scanDirSync(dirName, collectionName, subDir, entries);
+    }
+    const files = this.fs.listFilesSync(dirPath);
+    for (const filePath of files) {
+      const fileName = this.fs.basename(filePath);
+      if (fileName === COLLECTION_ORDER_FILE) continue;
+      const ext = this.fs.extname(fileName);
+      const content = this.fs.readFileSync(filePath);
+      const relativePath = this.fs.relative(dirName, filePath);
+      const slug = this.fs.normalizeSlug(relativePath, ext).split("/").map((segment) => slugify(segment)).join("/");
+      if (ext === ".mdx") {
+        entries.push(this.buildMdxEntry(collectionName, slug, fileName, content));
+      } else if (ext === ".json") {
+        entries.push(...this.buildJsonEntries(collectionName, slug, content));
+      }
+    }
+  }
+  buildMdxEntry(collectionName, slug, fileName, content) {
+    const parsed = parseMdx(content);
+    const locale = parseLocaleFromFilename(fileName);
+    const normalizedSlug = stripLocaleFromSlug(slug, locale);
+    return {
+      collection: collectionName,
+      slug: normalizedSlug,
+      path: `/${collectionName}/${normalizedSlug}`,
+      body: parsed.body,
+      data: parsed.data,
+      ...locale ? { locale } : {}
+    };
+  }
+  buildJsonEntries(collectionName, slug, content) {
+    const parsed = parseJson(content);
+    if (parsed.type === "json-array") {
+      return parsed.entries.map((data, index) => {
+        const entrySlug = typeof data["slug"] === "string" ? slugify(data["slug"]) : `${slug}/${index}`;
+        return {
+          collection: collectionName,
+          slug: entrySlug,
+          path: `/${collectionName}/${entrySlug}`,
+          data
+        };
+      });
+    }
+    return [{ collection: collectionName, slug, path: `/${collectionName}/${slug}`, data: parsed.data }];
+  }
+  async readOrdering(orderPath) {
+    if (!await this.fs.exists(orderPath)) return null;
+    try {
+      const content = await this.fs.readFile(orderPath);
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) return parsed;
+    } catch (error) {
+      console.warn(`[Nextjs Studio] Failed to parse ordering file: ${orderPath}`, error);
+    }
+    return null;
+  }
+  readOrderingSync(orderPath) {
+    if (!this.fs.existsSync(orderPath)) return null;
+    try {
+      const content = this.fs.readFileSync(orderPath);
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) return parsed;
+    } catch (error) {
+      console.warn(`[Nextjs Studio] Failed to parse ordering file: ${orderPath}`, error);
+    }
+    return null;
+  }
+  applyOrdering(entries, ordering) {
+    const orderMap = new Map(ordering.map((slug, index) => [slug, index]));
+    entries.sort((a, b) => {
+      const aIndex = orderMap.get(a.slug) ?? Infinity;
+      const bIndex = orderMap.get(b.slug) ?? Infinity;
+      return aIndex - bIndex;
+    });
+  }
+  detectCollectionType(entries) {
+    if (entries.length === 0) return "mdx";
+    const first = entries[0];
+    if (first.body !== void 0) return "mdx";
+    if (entries.length === 1 && !first.slug.includes("/")) return "json-object";
+    return "json-array";
+  }
+};
+
+// src/core/content-store.ts
+var store = null;
+function getStore() {
+  if (!store) {
+    throw new Error(
+      "Content not loaded. Auto-init requires 'nextjs-studio/server' \u2014 use loadContentSync() in a server context, or queryCollection() will auto-init when imported from 'nextjs-studio/server'."
+    );
+  }
+  return store;
+}
+function setStore(index) {
+  store = index;
+}
+function hasStore() {
+  return store !== null;
+}
+async function loadContent(fsAdapter, config) {
+  const index = new ContentIndex(fsAdapter);
+  await index.build(config);
+  store = index;
+  return index;
+}
+function loadContentSync(fsAdapter, config) {
+  const index = new ContentIndex(fsAdapter);
+  index.buildSync(config);
+  store = index;
+  return index;
+}
+
+// src/core/config-loader.ts
+import { existsSync } from "fs";
+import path2 from "path";
+import { pathToFileURL } from "url";
+function resolveConfigPath(projectRoot) {
+  for (const filename of CONFIG_FILENAMES) {
+    const fullPath = path2.resolve(projectRoot, filename);
+    if (existsSync(fullPath)) return fullPath;
+  }
+  return void 0;
+}
+async function loadStudioConfig(projectRoot) {
+  const configPath = resolveConfigPath(projectRoot);
+  if (!configPath) return {};
+  return loadConfigFromPath(configPath);
+}
+async function loadConfigFromPath(configPath) {
+  try {
+    const fileUrl = pathToFileURL(configPath).href;
+    const mod = await import(
+      /* webpackIgnore: true */
+      fileUrl
+    );
+    const config = mod.default ?? mod.config ?? mod;
+    if (typeof config !== "object" || config === null || Array.isArray(config)) {
+      return {};
+    }
+    return config;
+  } catch {
+    return {};
+  }
+}
+
+// src/core/query-builder.ts
+import { filter, orderBy, get, slice } from "lodash-es";
+
+// src/core/draft-filter.ts
+function isDraft(entry) {
+  return entry.data.draft === true;
+}
+
+// src/core/query-builder.ts
+var QueryBuilder = class {
+  collectionName;
+  options = {};
+  _excludeDrafts = false;
+  _locale;
+  constructor(collection) {
+    this.collectionName = collection;
+  }
+  where(conditions) {
+    this.options.where = { ...this.options.where, ...conditions };
+    return this;
+  }
+  sort(field, order = "asc") {
+    this.options.sort = { field, order };
+    return this;
+  }
+  limit(count) {
+    this.options.limit = count;
+    return this;
+  }
+  offset(count) {
+    this.options.offset = count;
+    return this;
+  }
+  excludeDrafts() {
+    this._excludeDrafts = true;
+    return this;
+  }
+  locale(code) {
+    this._locale = code;
+    return this;
+  }
+  all() {
+    let entries = [...getStore().getCollection(this.collectionName)];
+    if (this._excludeDrafts) {
+      entries = entries.filter((entry) => !isDraft(entry));
+    }
+    if (this._locale) {
+      const loc = this._locale;
+      entries = entries.filter((entry) => entry.locale === loc);
+    }
+    if (this.options.where) {
+      const conditions = this.options.where;
+      entries = filter(
+        entries,
+        (entry) => Object.entries(conditions).every(([key, value]) => get(entry.data, key) === value)
+      );
+    }
+    if (this.options.sort) {
+      const { field, order } = this.options.sort;
+      entries = orderBy(entries, [(entry) => get(entry.data, field)], [order]);
+    }
+    const start = this.options.offset ?? 0;
+    const end = this.options.limit ? start + this.options.limit : void 0;
+    return slice(entries, start, end).map((e) => ({
+      collection: e.collection,
+      slug: e.slug,
+      path: e.path,
+      body: e.body,
+      locale: e.locale,
+      ...e.data
+    }));
+  }
+  first() {
+    return this.limit(1).all()[0];
+  }
+  one() {
+    const result = this.limit(1).all()[0];
+    if (result === void 0) {
+      throw new Error(`Collection "${this.collectionName}" is empty \u2014 expected exactly one entry.`);
+    }
+    return result;
+  }
+  count() {
+    return this.all().length;
+  }
+};
+var FLUENT_METHODS = /* @__PURE__ */ new Set(["where", "sort", "limit", "offset", "excludeDrafts", "locale"]);
+function wrapWithArrayProxy(builder) {
+  let cache = null;
+  return new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (FLUENT_METHODS.has(String(prop))) {
+        const method = Reflect.get(target, prop);
+        return (...args) => {
+          cache = null;
+          method.apply(target, args);
+          return receiver;
+        };
+      }
+      if (prop in target) {
+        const value2 = Reflect.get(target, prop, receiver);
+        return typeof value2 === "function" ? value2.bind(target) : value2;
+      }
+      if (!cache) cache = target.all();
+      const value = Reflect.get(cache, prop);
+      return typeof value === "function" ? value.bind(cache) : value;
+    }
+  });
+}
+function queryCollection(name) {
+  return wrapWithArrayProxy(new QueryBuilder(name));
+}
+
+// src/core/server.ts
+if (!hasStore()) {
+  const dir = path3.join(process.cwd(), CONTENTS_DIR);
+  const index = new ContentIndex(new FsAdapter(dir));
+  index.buildSync();
+  setStore(index);
+}
+export {
+  ContentIndex,
+  FsAdapter,
+  loadConfigFromPath,
+  loadContent,
+  loadContentSync,
+  loadStudioConfig,
+  queryCollection,
+  resolveConfigPath
+};
+//# sourceMappingURL=server.js.map