@digitalculture/ochre-sdk 0.5.18 → 0.6.0

package/dist/index.cjs

@@ -20,17 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  fetchBibliography: () => fetchBibliography,
   fetchByUuid: () => fetchByUuid,
-  fetchConcept: () => fetchConcept,
-  fetchGallery: () => fetchGallery,
-  fetchPeriod: () => fetchPeriod,
-  fetchPropertyValue: () => fetchPropertyValue,
-  fetchResource: () => fetchResource,
-  fetchSet: () => fetchSet,
-  fetchSpatialUnit: () => fetchSpatialUnit,
-  fetchTree: () => fetchTree,
-  fetchWebsite: () => fetchWebsite,
+  fetchItem: () => fetchItem,
   filterProperties: () => filterProperties,
   getAllPropertyLabels: () => getAllPropertyLabels,
   getPropertyByLabel: () => getPropertyByLabel,
@@ -79,55 +70,241 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/utils/parse.ts
-var import_zod3 = require("zod");
-
-// src/utils/fetchers/generic.ts
+// src/schemas.ts
 var import_zod = require("zod");
 var uuidSchema = import_zod.z.string().uuid({ message: "Invalid UUID provided" });
-async function fetchByUuid(uuid) {
-  try {
-    const result = uuidSchema.safeParse(uuid);
-    if (!result.success) {
-      throw new Error(result.error.issues[0]?.message);
-    }
-    const response = await fetch(
-      `https://ochre.lib.uchicago.edu/ochre?uuid=${uuid}&format=json&lang="*"`
-    );
-    if (!response.ok) {
-      throw new Error("Failed to fetch OCHRE data");
-    }
-    const dataRaw = await response.json();
-    if (!("ochre" in dataRaw)) {
-      throw new Error("Invalid OCHRE data: API response missing 'ochre' key");
-    }
-    return [null, dataRaw];
-  } catch (error) {
-    return [error instanceof Error ? error.message : "Unknown error", null];
-  }
-}
-
-// src/utils/string.ts
-var import_zod2 = require("zod");
-var renderOptionsSchema = import_zod2.z.string().transform((str) => str.split(" ")).pipe(
-  import_zod2.z.array(
-    import_zod2.z.enum([
+var websiteSchema = import_zod.z.object({
+  type: import_zod.z.enum(
+    [
+      "traditional",
+      "digital-collection",
+      "plum",
+      "cedar",
+      "elm",
+      "maple",
+      "oak",
+      "palm"
+    ],
+    { message: "Invalid website type" }
+  ),
+  status: import_zod.z.enum(
+    ["development", "preview", "production"],
+    { message: "Invalid website status" }
+  ),
+  privacy: import_zod.z.enum(
+    ["public", "password", "private"],
+    { message: "Invalid website privacy" }
+  )
+});
+var componentSchema = import_zod.z.enum(
+  [
+    "annotated-document",
+    "annotated-image",
+    "bibliography",
+    "blog",
+    "button",
+    "collection",
+    "empty-space",
+    "filter-categories",
+    "iframe",
+    "iiif-viewer",
+    "image",
+    "image-gallery",
+    "n-columns",
+    "n-rows",
+    "network-graph",
+    "search-bar",
+    "table",
+    "text",
+    "timeline",
+    "video"
+  ],
+  { message: "Invalid component" }
+);
+var categorySchema = import_zod.z.enum([
+  "resource",
+  "spatialUnit",
+  "concept",
+  "period",
+  "bibliography",
+  "person",
+  "propertyValue",
+  "set",
+  "tree"
+]);
+var renderOptionsSchema = import_zod.z.string().transform((str) => str.split(" ")).pipe(
+  import_zod.z.array(
+    import_zod.z.enum([
       "bold",
       "italic",
       "underline"
     ])
   )
 );
-var whitespaceSchema = import_zod2.z.string().transform((str) => str.split(" ")).pipe(
-  import_zod2.z.array(
-    import_zod2.z.enum([
+var whitespaceSchema = import_zod.z.string().transform((str) => str.split(" ")).pipe(
+  import_zod.z.array(
+    import_zod.z.enum([
       "newline",
       "trailing",
       "leading"
     ])
   )
 );
-var emailSchema = import_zod2.z.string().email({ message: "Invalid email" });
+var emailSchema = import_zod.z.string().email({ message: "Invalid email" });
+
+// src/utils/helpers.ts
+function getItemCategory(keys) {
+  const categoryFound = keys.find(
+    (key) => categorySchema.safeParse(key).success
+  );
+  if (!categoryFound) {
+    const unknownKey = keys.find(
+      (key) => ![
+        "uuid",
+        "uuidBelongsTo",
+        "belongsTo",
+        "publicationDateTime",
+        "metadata",
+        "languages"
+      ].includes(key)
+    );
+    throw new Error(`Invalid OCHRE data; found unexpected "${unknownKey}" key`);
+  }
+  const categoryKey = categorySchema.parse(categoryFound);
+  return categoryKey;
+}
+
+// src/utils/getters.ts
+var DEFAULT_OPTIONS = {
+  searchNestedProperties: false
+};
+function getPropertyByLabel(properties, label, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const property = properties.find((property2) => property2.label === label);
+  if (property) {
+    return property;
+  }
+  if (searchNestedProperties) {
+    for (const property2 of properties) {
+      if (property2.properties.length > 0) {
+        const nestedResult = getPropertyByLabel(property2.properties, label, {
+          searchNestedProperties
+        });
+        if (nestedResult) {
+          return nestedResult;
+        }
+      }
+    }
+  }
+  return null;
+}
+function getPropertyValuesByLabel(properties, label, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const property = properties.find((property2) => property2.label === label);
+  if (property) {
+    return property.values.map((value) => value.content);
+  }
+  if (searchNestedProperties) {
+    for (const property2 of properties) {
+      if (property2.properties.length > 0) {
+        const nestedResult = getPropertyValuesByLabel(
+          property2.properties,
+          label,
+          { searchNestedProperties }
+        );
+        if (nestedResult) {
+          return nestedResult;
+        }
+      }
+    }
+  }
+  return null;
+}
+function getPropertyValueByLabel(properties, label, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const values = getPropertyValuesByLabel(properties, label, {
+    searchNestedProperties
+  });
+  if (values !== null && values.length > 0) {
+    return values[0];
+  }
+  if (searchNestedProperties) {
+    for (const property of properties) {
+      if (property.properties.length > 0) {
+        const nestedResult = getPropertyValueByLabel(
+          property.properties,
+          label,
+          { searchNestedProperties }
+        );
+        if (nestedResult !== null) {
+          return nestedResult;
+        }
+      }
+    }
+  }
+  return null;
+}
+function getAllPropertyLabels(properties, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const labels = /* @__PURE__ */ new Set();
+  for (const property of properties) {
+    labels.add(property.label);
+    if (property.properties.length > 0 && searchNestedProperties) {
+      const nestedLabels = getAllPropertyLabels(property.properties, {
+        searchNestedProperties: true
+      });
+      for (const label of nestedLabels) {
+        labels.add(label);
+      }
+    }
+  }
+  return [...labels];
+}
+function filterProperties(property, filter, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const isAllFields = filter.label.toLocaleLowerCase("en-US") === "all fields";
+  if (isAllFields || property.label.toLocaleLowerCase("en-US") === filter.label.toLocaleLowerCase("en-US")) {
+    let isFound = property.values.some((value) => {
+      if (value.content === null) {
+        return false;
+      }
+      if (typeof value.content === "string") {
+        if (typeof filter.value !== "string") {
+          return false;
+        }
+        return value.content.toLocaleLowerCase("en-US").includes(filter.value.toLocaleLowerCase("en-US"));
+      }
+      if (typeof value.content === "number") {
+        if (typeof filter.value !== "number") {
+          return false;
+        }
+        return value.content === filter.value;
+      }
+      if (typeof value.content === "boolean") {
+        if (typeof filter.value !== "boolean") {
+          return false;
+        }
+        return value.booleanValue === filter.value;
+      }
+      if (value.content instanceof Date) {
+        if (!(filter.value instanceof Date)) {
+          return false;
+        }
+        return value.content.getTime() === filter.value.getTime();
+      }
+      return false;
+    });
+    if (!isFound && searchNestedProperties) {
+      isFound = property.properties.some(
+        (property2) => filterProperties(property2, filter, { searchNestedProperties: true })
+      );
+    }
+    return isFound;
+  }
+  return false;
+}
+
+// src/utils/string.ts
 function getStringItemByLanguage(content, language) {
   const stringItemToFind = content.find((item) => item.lang === language);
   return stringItemToFind ?? null;
@@ -370,267 +547,42 @@ function parseStringDocumentItem(item, footnotes) {
     }
   }
   return returnString.replaceAll(/^(\d+)\./gm, String.raw`$1\.`);
-}
-function parseStringContent(content, language = "eng") {
-  switch (typeof content.content) {
-    case "string":
-    case "number":
-    case "boolean": {
-      return parseFakeString(content.content);
-    }
-    case "object": {
-      if (Array.isArray(content.content)) {
-        const stringItem = getStringItemByLanguage(content.content, language);
-        if (stringItem) {
-          return parseStringItem(stringItem);
-        } else {
-          const returnStringItem = content.content[0];
-          if (!returnStringItem) {
-            throw new Error(
-              `No string item found for language \u201C${language}\u201D in the following content:
-${JSON.stringify(
-                content.content
-              )}.`
-            );
-          }
-          return parseStringItem(returnStringItem);
-        }
-      } else {
-        return parseStringItem(content.content);
-      }
-    }
-    default: {
-      return String(content.content).replaceAll(/^(\d+)\./gm, String.raw`$1\.`);
-    }
-  }
-}
-
-// src/utils/fetchers/resource.ts
-async function fetchResource(uuid) {
-  try {
-    const [error, dataRaw] = await fetchByUuid(uuid);
-    if (error !== null) {
-      throw new Error(error);
-    }
-    if (!("resource" in dataRaw.ochre)) {
-      throw new Error(
-        "Invalid OCHRE data: API response missing 'resource' key"
-      );
-    }
-    const resourceItem = parseResource(dataRaw.ochre.resource);
-    const data = {
-      uuid: parseFakeString(dataRaw.ochre.uuid),
-      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
-      belongsTo: {
-        uuid: dataRaw.ochre.uuidBelongsTo,
-        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
-      },
-      metadata: parseMetadata(dataRaw.ochre.metadata),
-      item: resourceItem
-    };
-    return { metadata: data.metadata, resource: data.item };
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
-}
-
-// src/utils/getters.ts
-var DEFAULT_OPTIONS = {
-  searchNestedProperties: false
-};
-function getPropertyByLabel(properties, label, options = DEFAULT_OPTIONS) {
-  const { searchNestedProperties } = options;
-  const property = properties.find((property2) => property2.label === label);
-  if (property) {
-    return property;
-  }
-  if (searchNestedProperties) {
-    for (const property2 of properties) {
-      if (property2.properties.length > 0) {
-        const nestedResult = getPropertyByLabel(property2.properties, label, {
-          searchNestedProperties
-        });
-        if (nestedResult) {
-          return nestedResult;
-        }
-      }
-    }
-  }
-  return null;
-}
-function getPropertyValuesByLabel(properties, label, options = DEFAULT_OPTIONS) {
-  const { searchNestedProperties } = options;
-  const property = properties.find((property2) => property2.label === label);
-  if (property) {
-    return property.values.map((value) => value.content);
-  }
-  if (searchNestedProperties) {
-    for (const property2 of properties) {
-      if (property2.properties.length > 0) {
-        const nestedResult = getPropertyValuesByLabel(
-          property2.properties,
-          label,
-          { searchNestedProperties }
-        );
-        if (nestedResult) {
-          return nestedResult;
-        }
-      }
-    }
-  }
-  return null;
-}
-function getPropertyValueByLabel(properties, label, options = DEFAULT_OPTIONS) {
-  const { searchNestedProperties } = options;
-  const values = getPropertyValuesByLabel(properties, label, {
-    searchNestedProperties
-  });
-  if (values !== null && values.length > 0) {
-    return values[0];
-  }
-  if (searchNestedProperties) {
-    for (const property of properties) {
-      if (property.properties.length > 0) {
-        const nestedResult = getPropertyValueByLabel(
-          property.properties,
-          label,
-          { searchNestedProperties }
-        );
-        if (nestedResult !== null) {
-          return nestedResult;
-        }
-      }
-    }
-  }
-  return null;
-}
-function getAllPropertyLabels(properties, options = DEFAULT_OPTIONS) {
-  const { searchNestedProperties } = options;
-  const labels = /* @__PURE__ */ new Set();
-  for (const property of properties) {
-    labels.add(property.label);
-    if (property.properties.length > 0 && searchNestedProperties) {
-      const nestedLabels = getAllPropertyLabels(property.properties, {
-        searchNestedProperties: true
-      });
-      for (const label of nestedLabels) {
-        labels.add(label);
-      }
-    }
-  }
-  return [...labels];
-}
-function filterProperties(property, filter, options = DEFAULT_OPTIONS) {
-  const { searchNestedProperties } = options;
-  const isAllFields = filter.label.toLocaleLowerCase("en-US") === "all fields";
-  if (isAllFields || property.label.toLocaleLowerCase("en-US") === filter.label.toLocaleLowerCase("en-US")) {
-    let isFound = property.values.some((value) => {
-      if (value.content === null) {
-        return false;
-      }
-      if (typeof value.content === "string") {
-        if (typeof filter.value !== "string") {
-          return false;
-        }
-        return value.content.toLocaleLowerCase("en-US").includes(filter.value.toLocaleLowerCase("en-US"));
-      }
-      if (typeof value.content === "number") {
-        if (typeof filter.value !== "number") {
-          return false;
-        }
-        return value.content === filter.value;
-      }
-      if (typeof value.content === "boolean") {
-        if (typeof filter.value !== "boolean") {
-          return false;
-        }
-        return value.booleanValue === filter.value;
-      }
-      if (value.content instanceof Date) {
-        if (!(filter.value instanceof Date)) {
-          return false;
-        }
-        return value.content.getTime() === filter.value.getTime();
-      }
-      return false;
-    });
-    if (!isFound && searchNestedProperties) {
-      isFound = property.properties.some(
-        (property2) => filterProperties(property2, filter, { searchNestedProperties: true })
-      );
-    }
-    return isFound;
-  }
-  return false;
-}
-
-// src/utils/parse.ts
-var websiteSchema = import_zod3.z.object({
-  type: import_zod3.z.enum(
-    [
-      "traditional",
-      "digital-collection",
-      "plum",
-      "cedar",
-      "elm",
-      "maple",
-      "oak",
-      "palm"
-    ],
-    { message: "Invalid website type" }
-  ),
-  status: import_zod3.z.enum(
-    ["development", "preview", "production"],
-    { message: "Invalid website status" }
-  ),
-  privacy: import_zod3.z.enum(
-    ["public", "password", "private"],
-    { message: "Invalid website privacy" }
-  )
-});
-var resourceTypeSchema = import_zod3.z.enum(
-  [
-    "audio",
-    "document",
-    "drawing",
-    "FITS",
-    "geospatial",
-    "IIIF",
-    "image",
-    "model",
-    "PTM",
-    "TEI",
-    "video",
-    "webpage"
-  ],
-  { message: "Invalid resource type" }
-);
-var componentSchema = import_zod3.z.enum(
-  [
-    "annotated-document",
-    "annotated-image",
-    "bibliography",
-    "blog",
-    "button",
-    "collection",
-    "empty-space",
-    "filter-categories",
-    "iframe",
-    "iiif-viewer",
-    "image",
-    "image-gallery",
-    "n-columns",
-    "n-rows",
-    "network-graph",
-    "search-bar",
-    "table",
-    "text",
-    "timeline",
-    "video"
-  ],
-  { message: "Invalid component" }
-);
+}
+function parseStringContent(content, language = "eng") {
+  switch (typeof content.content) {
+    case "string":
+    case "number":
+    case "boolean": {
+      return parseFakeString(content.content);
+    }
+    case "object": {
+      if (Array.isArray(content.content)) {
+        const stringItem = getStringItemByLanguage(content.content, language);
+        if (stringItem) {
+          return parseStringItem(stringItem);
+        } else {
+          const returnStringItem = content.content[0];
+          if (!returnStringItem) {
+            throw new Error(
+              `No string item found for language \u201C${language}\u201D in the following content:
+${JSON.stringify(
+                content.content
+              )}.`
+            );
+          }
+          return parseStringItem(returnStringItem);
+        }
+      } else {
+        return parseStringItem(content.content);
+      }
+    }
+    default: {
+      return String(content.content).replaceAll(/^(\d+)\./gm, String.raw`$1\.`);
+    }
+  }
+}
+
+// src/utils/parse.ts
 function parseIdentification(identification) {
   try {
     const returnIdentification = {
@@ -1040,13 +992,10 @@ function parsePeriods(periods) {
 function parseBibliography(bibliography) {
   let resource = null;
   if (bibliography.source?.resource) {
-    const resourceType = resourceTypeSchema.parse(
-      bibliography.source.resource.type
-    );
     resource = {
       uuid: bibliography.source.resource.uuid,
       publicationDateTime: bibliography.source.resource.publicationDateTime ? new Date(bibliography.source.resource.publicationDateTime) : null,
-      type: resourceType,
+      type: bibliography.source.resource.type,
       identification: parseIdentification(
         bibliography.source.resource.identification
       )
@@ -1218,54 +1167,83 @@ function parseTree(tree) {
   return returnTree;
 }
 function parseSet(set) {
-  let resources = [];
-  let spatialUnits = [];
-  let concepts = [];
-  let periods = [];
-  let bibliographies = [];
-  let persons = [];
-  let propertyValues = [];
-  if (typeof set.items !== "string" && "resource" in set.items) {
-    resources = parseResources(
-      Array.isArray(set.items.resource) ? set.items.resource : [set.items.resource],
-      true
-    );
-  }
-  if (typeof set.items !== "string" && "spatialUnit" in set.items) {
-    spatialUnits = parseSpatialUnits(
-      Array.isArray(set.items.spatialUnit) ? set.items.spatialUnit : [set.items.spatialUnit],
-      true
-    );
-  }
-  if (typeof set.items !== "string" && "concept" in set.items) {
-    concepts = parseConcepts(
-      Array.isArray(set.items.concept) ? set.items.concept : [set.items.concept],
-      true
-    );
-  }
-  if (typeof set.items !== "string" && "period" in set.items) {
-    periods = parsePeriods(
-      Array.isArray(set.items.period) ? set.items.period : [set.items.period]
-    );
-  }
-  if (typeof set.items !== "string" && "bibliography" in set.items) {
-    bibliographies = parseBibliographies(
-      Array.isArray(set.items.bibliography) ? set.items.bibliography : [set.items.bibliography]
-    );
-  }
-  if (typeof set.items !== "string" && "person" in set.items) {
-    persons = parsePersons(
-      Array.isArray(set.items.person) ? set.items.person : [set.items.person]
-    );
-  }
-  if (typeof set.items !== "string" && "propertyValue" in set.items) {
-    propertyValues = parsePropertyValues(
-      Array.isArray(set.items.propertyValue) ? set.items.propertyValue : [set.items.propertyValue]
-    );
+  if (typeof set.items === "string") {
+    throw new TypeError("Invalid OCHRE data: Set has no items");
+  }
+  const itemCategory = getItemCategory(Object.keys(set.items));
+  let items = [];
+  switch (itemCategory) {
+    case "resource": {
+      if (!("resource" in set.items)) {
+        throw new Error("Invalid OCHRE data: Set has no resources");
+      }
+      items = parseResources(
+        Array.isArray(set.items.resource) ? set.items.resource : [set.items.resource]
+      );
+      break;
+    }
+    case "spatialUnit": {
+      if (!("spatialUnit" in set.items)) {
+        throw new Error("Invalid OCHRE data: Set has no spatial units");
+      }
+      items = parseSpatialUnits(
+        Array.isArray(set.items.spatialUnit) ? set.items.spatialUnit : [set.items.spatialUnit]
+      );
+      break;
+    }
+    case "concept": {
+      if (!("concept" in set.items)) {
+        throw new Error("Invalid OCHRE data: Set has no concepts");
+      }
+      items = parseConcepts(
+        Array.isArray(set.items.concept) ? set.items.concept : [set.items.concept]
+      );
+      break;
+    }
+    case "period": {
+      if (!("period" in set.items)) {
+        throw new Error("Invalid OCHRE data: Set has no periods");
+      }
+      items = parsePeriods(
+        Array.isArray(set.items.period) ? set.items.period : [set.items.period]
+      );
+      break;
+    }
+    case "bibliography": {
+      if (!("bibliography" in set.items)) {
+        throw new Error("Invalid OCHRE data: Set has no bibliographies");
+      }
+      items = parseBibliographies(
+        Array.isArray(set.items.bibliography) ? set.items.bibliography : [set.items.bibliography]
+      );
+      break;
+    }
+    case "person": {
+      if (!("person" in set.items)) {
+        throw new Error("Invalid OCHRE data: Set has no persons");
+      }
+      items = parsePersons(
+        Array.isArray(set.items.person) ? set.items.person : [set.items.person]
+      );
+      break;
+    }
+    case "propertyValue": {
+      if (!("propertyValue" in set.items)) {
+        throw new Error("Invalid OCHRE data: Set has no property values");
+      }
+      items = parsePropertyValues(
+        Array.isArray(set.items.propertyValue) ? set.items.propertyValue : [set.items.propertyValue]
+      );
+      break;
+    }
+    default: {
+      throw new Error("Invalid OCHRE data: Set has no items or is malformed");
+    }
   }
   return {
     uuid: set.uuid,
     category: "set",
+    itemCategory,
     publicationDateTime: set.publicationDateTime ? new Date(set.publicationDateTime) : null,
     date: set.date != null ? new Date(set.date) : null,
     license: parseLicense(set.availability),
@@ -1277,24 +1255,15 @@ function parseSet(set) {
     ) : [],
     type: set.type,
     number: set.n,
-    items: {
-      resources,
-      spatialUnits,
-      concepts,
-      periods,
-      bibliographies,
-      persons,
-      propertyValues
-    }
+    items
   };
 }
-function parseResource(resource, isNested = false) {
-  const resourceType = resourceTypeSchema.parse(resource.type);
+function parseResource(resource) {
   const returnResource = {
     uuid: resource.uuid,
     category: "resource",
     publicationDateTime: resource.publicationDateTime ? new Date(resource.publicationDateTime) : null,
-    type: resourceType,
+    type: resource.type,
     number: resource.n,
     format: resource.format ?? null,
     context: "context" in resource && resource.context ? parseContext(resource.context) : null,
@@ -1332,34 +1301,20 @@ function parseResource(resource, isNested = false) {
       Array.isArray(resource.citedBibliography.reference) ? resource.citedBibliography.reference : [resource.citedBibliography.reference]
     ) : [],
     resources: resource.resource ? parseResources(
-      Array.isArray(resource.resource) ? resource.resource : [resource.resource],
-      true
+      Array.isArray(resource.resource) ? resource.resource : [resource.resource]
     ) : []
   };
-  if (isNested) {
-    const returnNestedResource = {
-      ...returnResource,
-      publicationDateTime: null,
-      context: null,
-      license: null,
-      copyright: null
-    };
-    delete returnNestedResource.publicationDateTime;
-    delete returnNestedResource.license;
-    delete returnNestedResource.copyright;
-    return returnNestedResource;
-  }
   return returnResource;
 }
-function parseResources(resources, isNested = false) {
+function parseResources(resources) {
   const returnResources = [];
   const resourcesToParse = Array.isArray(resources) ? resources : [resources];
   for (const resource of resourcesToParse) {
-    returnResources.push(parseResource(resource, isNested));
+    returnResources.push(parseResource(resource));
   }
   return returnResources;
 }
-function parseSpatialUnit(spatialUnit, isNested = false) {
+function parseSpatialUnit(spatialUnit) {
   const returnSpatialUnit = {
     uuid: spatialUnit.uuid,
     category: "spatialUnit",
@@ -1379,34 +1334,22 @@ function parseSpatialUnit(spatialUnit, isNested = false) {
     ) : spatialUnit.observation ? [parseObservation(spatialUnit.observation)] : [],
     events: "events" in spatialUnit && spatialUnit.events ? parseEvents(
       Array.isArray(spatialUnit.events.event) ? spatialUnit.events.event : [spatialUnit.events.event]
+    ) : [],
+    properties: "properties" in spatialUnit && spatialUnit.properties ? parseProperties(
+      Array.isArray(spatialUnit.properties.property) ? spatialUnit.properties.property : [spatialUnit.properties.property]
     ) : []
   };
-  if (isNested) {
-    const returnNestedSpatialUnit = {
-      ...returnSpatialUnit,
-      publicationDateTime: null,
-      license: null,
-      properties: "properties" in spatialUnit && spatialUnit.properties ? parseProperties(
-        Array.isArray(spatialUnit.properties.property) ? spatialUnit.properties.property : [spatialUnit.properties.property]
-      ) : []
-    };
-    delete returnNestedSpatialUnit.publicationDateTime;
-    delete returnNestedSpatialUnit.license;
-    return returnNestedSpatialUnit;
-  }
   return returnSpatialUnit;
 }
-function parseSpatialUnits(spatialUnits, isNested = false) {
+function parseSpatialUnits(spatialUnits) {
   const returnSpatialUnits = [];
   const spatialUnitsToParse = Array.isArray(spatialUnits) ? spatialUnits : [spatialUnits];
   for (const spatialUnit of spatialUnitsToParse) {
-    returnSpatialUnits.push(
-      parseSpatialUnit(spatialUnit, isNested)
-    );
+    returnSpatialUnits.push(parseSpatialUnit(spatialUnit));
   }
   return returnSpatialUnits;
 }
-function parseConcept(concept, isNested = false) {
+function parseConcept(concept) {
   const returnConcept = {
     uuid: concept.uuid,
     category: "concept",
@@ -1419,17 +1362,6 @@ function parseConcept(concept, isNested = false) {
       Array.isArray(concept.interpretations.interpretation) ? concept.interpretations.interpretation : [concept.interpretations.interpretation]
     )
   };
-  if (isNested) {
-    const returnNestedConcept = {
-      ...returnConcept,
-      publicationDateTime: null,
-      context: null,
-      license: null
-    };
-    delete returnNestedConcept.publicationDateTime;
-    delete returnNestedConcept.license;
-    return returnNestedConcept;
-  }
   return returnConcept;
 }
 var parseWebpageResources = async (webpageResources, type) => {
@@ -1472,11 +1404,11 @@ var parseWebpageResources = async (webpageResources, type) => {
   }
   return returnElements;
 };
-function parseConcepts(concepts, isNested = false) {
+function parseConcepts(concepts) {
   const returnConcepts = [];
   const conceptsToParse = Array.isArray(concepts) ? concepts : [concepts];
   for (const concept of conceptsToParse) {
-    returnConcepts.push(parseConcept(concept, isNested));
+    returnConcepts.push(parseConcept(concept));
   }
   return returnConcepts;
 }
@@ -1497,11 +1429,11 @@ async function parseWebElementProperties(componentProperty, elementResource) {
   if (document === null) {
     const documentLink = links.find((link) => link.type === "internalDocument");
     if (documentLink) {
-      const documentResource = await fetchResource(documentLink.uuid);
-      if (documentResource === null) {
+      const { item, error } = await fetchItem(documentLink.uuid, "resource");
+      if (error !== null) {
         throw new Error("Failed to fetch OCHRE data");
       }
-      document = documentResource.resource.document;
+      document = item.document;
     }
   }
   switch (componentName) {
@@ -2542,301 +2474,145 @@ async function parseWebsite(websiteTree, projectName, website) {
   };
 }
 
-// src/utils/fetchers/bibliography.ts
-async function fetchBibliography(uuid) {
-  try {
-    const [error, dataRaw] = await fetchByUuid(uuid);
-    if (error !== null) {
-      throw new Error(error);
-    }
-    if (!("bibliography" in dataRaw.ochre)) {
-      throw new Error(
-        "Invalid OCHRE data: API response missing 'bibliography' key"
-      );
-    }
-    const bibliographyItem = parseBibliography(dataRaw.ochre.bibliography);
-    const data = {
-      uuid: parseFakeString(dataRaw.ochre.uuid),
-      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
-      belongsTo: {
-        uuid: dataRaw.ochre.uuidBelongsTo,
-        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
-      },
-      metadata: parseMetadata(dataRaw.ochre.metadata),
-      item: bibliographyItem
-    };
-    return { metadata: data.metadata, bibliography: data.item };
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
-}
-
-// src/utils/fetchers/concept.ts
-async function fetchConcept(uuid) {
-  try {
-    const [error, dataRaw] = await fetchByUuid(uuid);
-    if (error !== null) {
-      throw new Error(error);
-    }
-    if (!("concept" in dataRaw.ochre)) {
-      throw new Error("Invalid OCHRE data: API response missing 'concept' key");
-    }
-    const conceptItem = parseConcept(dataRaw.ochre.concept);
-    const data = {
-      uuid: parseFakeString(dataRaw.ochre.uuid),
-      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
-      belongsTo: {
-        uuid: dataRaw.ochre.uuidBelongsTo,
-        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
-      },
-      metadata: parseMetadata(dataRaw.ochre.metadata),
-      item: conceptItem
-    };
-    return { metadata: data.metadata, concept: data.item };
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
-}
-
-// src/utils/fetchers/gallery.ts
-var import_zod4 = require("zod");
-var gallerySchema = import_zod4.z.object({
-  uuid: import_zod4.z.string().uuid({ message: "Invalid UUID" }),
-  filter: import_zod4.z.string().optional(),
-  page: import_zod4.z.number().positive({ message: "Page must be positive" }),
-  perPage: import_zod4.z.number().positive({ message: "Per page must be positive" })
-}).strict();
-async function fetchGallery(uuid, filter, page, perPage) {
+// src/utils/fetchers/uuid.ts
+async function fetchByUuid(uuid) {
   try {
-    const parsed = gallerySchema.safeParse({ uuid, filter, page, perPage });
-    if (!parsed.success) {
-      throw new Error(parsed.error.message);
-    }
+    const parsedUuid = uuidSchema.parse(uuid);
     const response = await fetch(
-      `https://ochre.lib.uchicago.edu/ochre?xquery=${encodeURIComponent(`
-        for $q in input()/ochre[@uuid='${uuid}']
-        let $filtered := $q/tree/items/resource[contains(lower-case(identification/label), lower-case('${filter}'))]
-        let $maxLength := count($filtered)
-        return <gallery maxLength='{$maxLength}'>
-          {$q/metadata/project}
-          {$q/metadata/item}
-          {$filtered[position() >= ${((page - 1) * perPage + 1).toString()} and position() < ${(page * perPage + 1).toString()}]}
-        </gallery>
-      `)}&format=json`
+      `https://ochre.lib.uchicago.edu/ochre?uuid=${parsedUuid}&format=json&lang="*"`
     );
     if (!response.ok) {
-      throw new Error("Error fetching gallery items, please try again later.");
-    }
-    const data = await response.json();
-    if (!("gallery" in data.result)) {
-      throw new Error("Failed to fetch gallery");
+      throw new Error("Failed to fetch OCHRE data");
     }
-    const galleryIdentification = parseIdentification(
-      data.result.gallery.item.identification
-    );
-    const galleryProjectIdentification = parseIdentification(
-      data.result.gallery.project.identification
-    );
-    const gallery = {
-      identification: galleryIdentification,
-      projectIdentification: galleryProjectIdentification,
-      resources: data.result.gallery.resource ? Array.isArray(data.result.gallery.resource) ? parseResources(data.result.gallery.resource) : [parseResource(data.result.gallery.resource)] : [],
-      maxLength: data.result.gallery.maxLength
-    };
-    return gallery;
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
-}
-
-// src/utils/fetchers/period.ts
-async function fetchPeriod(uuid) {
-  try {
-    const [error, dataRaw] = await fetchByUuid(uuid);
-    if (error !== null) {
-      throw new Error(error);
+    const dataRaw = await response.json();
+    if (!("ochre" in dataRaw)) {
+      throw new Error("Invalid OCHRE data: API response missing 'ochre' key");
     }
-    if (!("period" in dataRaw.ochre)) {
-      throw new Error("Invalid OCHRE data: API response missing 'period' key");
-    }
-    const periodItem = parsePeriod(dataRaw.ochre.period);
-    const data = {
-      uuid: parseFakeString(dataRaw.ochre.uuid),
-      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
-      belongsTo: {
-        uuid: dataRaw.ochre.uuidBelongsTo,
-        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
-      },
-      metadata: parseMetadata(dataRaw.ochre.metadata),
-      item: periodItem
-    };
-    return { metadata: data.metadata, period: data.item };
+    return [null, dataRaw];
   } catch (error) {
-    console.error(error);
-    return null;
+    return [error instanceof Error ? error.message : "Unknown error", null];
   }
 }
 
-// src/utils/fetchers/property-value.ts
-async function fetchPropertyValue(uuid) {
+// src/utils/fetchers/item.ts
+async function fetchItem(uuid, category) {
   try {
-    const [error, dataRaw] = await fetchByUuid(uuid);
+    const [error, data] = await fetchByUuid(uuid);
     if (error !== null) {
       throw new Error(error);
     }
-    if (!("propertyValue" in dataRaw.ochre)) {
-      throw new Error(
-        "Invalid OCHRE data: API response missing 'propertyValue' key"
-      );
-    }
-    const propertyValueItem = parsePropertyValue(dataRaw.ochre.propertyValue);
-    const data = {
-      uuid: parseFakeString(dataRaw.ochre.uuid),
-      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
-      belongsTo: {
-        uuid: dataRaw.ochre.uuidBelongsTo,
-        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
-      },
-      metadata: parseMetadata(dataRaw.ochre.metadata),
-      item: propertyValueItem
-    };
-    return { metadata: data.metadata, propertyValue: data.item };
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
-}
-
-// src/utils/fetchers/set.ts
-async function fetchSet(uuid) {
-  try {
-    const [error, dataRaw] = await fetchByUuid(uuid);
-    if (error !== null) {
-      throw new Error(error);
+    const categoryKey = getItemCategory(Object.keys(data.ochre));
+    let item;
+    switch (categoryKey) {
+      case "resource": {
+        if (!("resource" in data.ochre)) {
+          throw new Error(
+            "Invalid OCHRE data: API response missing 'resource' key"
+          );
+        }
+        item = parseResource(data.ochre.resource);
+        break;
+      }
+      case "spatialUnit": {
+        if (!("spatialUnit" in data.ochre)) {
+          throw new Error(
+            "Invalid OCHRE data: API response missing 'spatialUnit' key"
+          );
+        }
+        item = parseSpatialUnit(data.ochre.spatialUnit);
+        break;
+      }
+      case "concept": {
+        if (!("concept" in data.ochre)) {
+          throw new Error(
+            "Invalid OCHRE data: API response missing 'concept' key"
+          );
+        }
+        item = parseConcept(data.ochre.concept);
+        break;
+      }
+      case "period": {
+        if (!("period" in data.ochre)) {
+          throw new Error(
+            "Invalid OCHRE data: API response missing 'period' key"
+          );
+        }
+        item = parsePeriod(data.ochre.period);
+        break;
+      }
+      case "bibliography": {
+        if (!("bibliography" in data.ochre)) {
+          throw new Error(
+            "Invalid OCHRE data: API response missing 'bibliography' key"
+          );
+        }
+        item = parseBibliography(data.ochre.bibliography);
+        break;
+      }
+      case "person": {
+        if (!("person" in data.ochre)) {
+          throw new Error(
+            "Invalid OCHRE data: API response missing 'person' key"
+          );
+        }
+        item = parsePerson(data.ochre.person);
+        break;
+      }
+      case "propertyValue": {
+        if (!("propertyValue" in data.ochre)) {
+          throw new Error(
+            "Invalid OCHRE data: API response missing 'propertyValue' key"
+          );
+        }
+        item = parsePropertyValue(data.ochre.propertyValue);
+        break;
+      }
+      case "set": {
+        if (!("set" in data.ochre)) {
+          throw new Error("Invalid OCHRE data: API response missing 'set' key");
+        }
+        item = parseSet(data.ochre.set);
+        break;
+      }
+      case "tree": {
+        if (!("tree" in data.ochre)) {
+          throw new Error(
+            "Invalid OCHRE data: API response missing 'tree' key"
+          );
+        }
+        item = parseTree(data.ochre.tree);
+        break;
+      }
+      default: {
+        throw new Error("Invalid category");
+      }
     }
-    if (!("set" in dataRaw.ochre)) {
-      throw new Error("Invalid OCHRE data: API response missing 'set' key");
-    }
-    const setItem = parseSet(dataRaw.ochre.set);
-    const data = {
-      uuid: parseFakeString(dataRaw.ochre.uuid),
-      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
-      belongsTo: {
-        uuid: dataRaw.ochre.uuidBelongsTo,
-        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
-      },
-      metadata: parseMetadata(dataRaw.ochre.metadata),
-      item: setItem
+    const metadata = parseMetadata(data.ochre.metadata);
+    const belongsTo = {
+      uuid: data.ochre.uuidBelongsTo,
+      abbreviation: parseFakeString(data.ochre.belongsTo)
     };
-    return { metadata: data.metadata, set: data.item };
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
-}
-
-// src/utils/fetchers/spatial-unit.ts
-async function fetchSpatialUnit(uuid) {
-  try {
-    const [error, dataRaw] = await fetchByUuid(uuid);
-    if (error !== null) {
-      throw new Error(error);
-    }
-    if (!("spatialUnit" in dataRaw.ochre)) {
-      throw new Error(
-        "Invalid OCHRE data: API response missing 'spatialUnit' key"
-      );
-    }
-    const spatialUnitItem = parseSpatialUnit(dataRaw.ochre.spatialUnit);
-    const data = {
-      uuid: parseFakeString(dataRaw.ochre.uuid),
-      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
-      belongsTo: {
-        uuid: dataRaw.ochre.uuidBelongsTo,
-        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
-      },
-      metadata: parseMetadata(dataRaw.ochre.metadata),
-      item: spatialUnitItem
+    return {
+      error: null,
+      metadata,
+      belongsTo,
+      item,
+      category
     };
-    return { metadata: data.metadata, spatialUnit: data.item };
   } catch (error) {
-    console.error(error);
-    return null;
-  }
-}
-
-// src/utils/fetchers/tree.ts
-async function fetchTree(uuid) {
-  try {
-    const [error, dataRaw] = await fetchByUuid(uuid);
-    if (error !== null) {
-      throw new Error(error);
-    }
-    if (!("tree" in dataRaw.ochre)) {
-      throw new Error("Invalid OCHRE data: API response missing 'tree' key");
-    }
-    const tree = parseTree(dataRaw.ochre.tree);
-    if (!tree) {
-      throw new Error("Invalid OCHRE data: Could not parse tree");
-    }
-    const data = {
-      uuid: parseFakeString(dataRaw.ochre.uuid),
-      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
-      belongsTo: {
-        uuid: dataRaw.ochre.uuidBelongsTo,
-        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
-      },
-      metadata: parseMetadata(dataRaw.ochre.metadata),
-      item: tree
+    return {
+      error: error instanceof Error ? error.message : "Unknown error",
+      metadata: void 0,
+      belongsTo: void 0,
+      item: void 0,
+      category: void 0
     };
-    return { metadata: data.metadata, tree: data.item };
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
-}
-
-// src/utils/fetchers/website.ts
-async function fetchWebsite(abbreviation) {
-  try {
-    const response = await fetch(
-      `https://ochre.lib.uchicago.edu/ochre?xquery=for $q in input()/ochre[tree[@type='lesson'][identification/abbreviation='${abbreviation.toLocaleLowerCase("en-US")}']] return $q&format=json`
-    );
-    if (!response.ok) {
-      throw new Error("Failed to fetch website");
-    }
-    const data = await response.json();
-    if (!("ochre" in data.result) || !("tree" in data.result.ochre)) {
-      throw new Error("Failed to fetch website");
-    }
-    const projectIdentification = data.result.ochre.metadata.project?.identification ? parseIdentification(data.result.ochre.metadata.project.identification) : null;
-    const website = await parseWebsite(
-      data.result.ochre.tree,
-      projectIdentification?.label ?? "",
-      data.result.ochre.metadata.project?.identification.website ?? null
-    );
-    return website;
-  } catch (error) {
-    console.error(error);
-    return null;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  fetchBibliography,
   fetchByUuid,
-  fetchConcept,
-  fetchGallery,
-  fetchPeriod,
-  fetchPropertyValue,
-  fetchResource,
-  fetchSet,
-  fetchSpatialUnit,
-  fetchTree,
-  fetchWebsite,
+  fetchItem,
   filterProperties,
   getAllPropertyLabels,
   getPropertyByLabel,