@recipe-book/core 0.0.3 → 0.1.1

package/dist/schema-org/from-json-ld.js

@@ -0,0 +1,647 @@
+// src/schema-org/from-json-ld.ts
+import {
+  describeValue,
+  quote
+} from "../errors.js";
+import { parseIngredientLine } from "../ingredient/parse.js";
+import { issue, warning } from "../issues.js";
+import { matchAmount } from "../quantity/parse.js";
+import { parseIsoDuration } from "../recipe/duration.js";
+import { parseRecipeWith } from "../recipe/parse.js";
+import { disallowedScheme } from "../recipe/url.js";
+import { asRecord, toResult } from "../validation.js";
+import { entriesOf, locate, MAX_DEPTH } from "./find.js";
+import { NUTRIENTS } from "./nutrients.js";
+import { cleanLines, cleanText } from "./text.js";
+var READ_FIELDS = [
+  "@context",
+  "@type",
+  "name",
+  "description",
+  "image",
+  "recipeYield",
+  "prepTime",
+  "cookTime",
+  "totalTime",
+  "recipeIngredient",
+  "recipeInstructions",
+  "tool",
+  "nutrition"
+];
+var TIMES = [
+  ["prep", "prepTime"],
+  ["cook", "cookTime"],
+  ["total", "totalTime"]
+];
+var MAX_URL_LENGTH = 4096;
+var SERVINGS_WORD = /^(?:servings?|portions?|(?:serving|portion)\(s\)|people|persons?)\.?$/i;
+function fromJsonLd(input) {
+  const { recipes, ids } = locate([input]);
+  const [found] = recipes;
+  if (!found) {
+    return {
+      ...toResult("invalid_recipe", void 0, [
+        issue(
+          "error",
+          "invalid_type",
+          [],
+          `Expected a schema.org Recipe, or an array, @graph, mainEntity, or ItemList that holds one, received ${describeValue(input)}.`
+        )
+      ]),
+      extra: {}
+    };
+  }
+  const node = asRecord(found.node);
+  const reader = {
+    recipe: found.node,
+    ids,
+    warnings: [],
+    sources: /* @__PURE__ */ new Map(),
+    droppable: /* @__PURE__ */ new Set(),
+    images: [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()],
+    repeated: 0,
+    deepest: 0
+  };
+  const name = text(node.name);
+  if (recipes.length > 1) {
+    warning(
+      reader.warnings,
+      "ignored_value",
+      [],
+      `Found ${recipes.length} recipes. Only the first${typeof name === "string" ? `, ${quote(name)},` : ""} is read.`
+    );
+  }
+  const model = readRecipe(reader, node, found.path);
+  const parse = () => parseRecipeWith(model, parseIngredientLine);
+  let result = parse();
+  const dropped = [];
+  if (!result.success) {
+    const targets = [];
+    for (const error of result.error.issues) {
+      const target = error.severity === "error" ? droppableAt(reader, error.path) : void 0;
+      if (target) {
+        targets.push(target);
+        dropped.push({
+          ...error,
+          severity: "warning",
+          message: `${error.message} It is ignored.`
+        });
+      }
+    }
+    targets.sort((a, b) => b.length - a.length).forEach((target) => remove(model, target));
+    if (dropped.length > 0) {
+      result = parse();
+    }
+  }
+  const order = ({ code, path }) => [
+    path.length > found.path.length ? READ_FIELDS.indexOf(String(path[found.path.length])) : -1,
+    ...path.slice(found.path.length + 1).filter((key) => typeof key === "number"),
+    ...code === "unknown_field" ? [Infinity] : []
+  ];
+  const issues = [
+    ...reader.warnings,
+    ...[
+      ...dropped,
+      ...result.success ? result.warnings : result.error.issues
+    ].map((issue2) => ({ ...issue2, path: sourceOf(reader, issue2.path) }))
+  ].sort((a, b) => compareOrder(order(a), order(b)));
+  const checked = /* @__PURE__ */ new Map();
+  const extra = Object.fromEntries(
+    Object.entries(node).filter(([key, value]) => {
+      if (READ_FIELDS.includes(key)) {
+        return false;
+      }
+      const path = [...found.path, key];
+      if (tooDeep(value, path.length, checked)) {
+        warning(
+          issues,
+          "invalid_type",
+          path,
+          `Expected a value to keep in extra, received ${describeValue(value)} nested more than ${MAX_DEPTH} levels deep. It is ignored.`
+        );
+        return false;
+      }
+      return true;
+    })
+  );
+  return {
+    ...toResult(
+      "invalid_recipe",
+      result.success ? result.data : void 0,
+      issues,
+      typeof name === "string" ? quote(name) : void 0
+    ),
+    extra
+  };
+}
+function tooDeep(value, length, checked) {
+  if (length > MAX_DEPTH) {
+    return true;
+  }
+  if (typeof value !== "object" || value === null || (checked.get(value) ?? 0) >= length) {
+    return false;
+  }
+  const deep = Object.values(value).some(
+    (child) => tooDeep(child, length + 1, checked)
+  );
+  if (!deep) {
+    checked.set(value, length);
+  }
+  return deep;
+}
+function readRecipe(reader, node, base) {
+  const at = (...path) => [...base, ...path];
+  const model = {
+    name: text(node.name),
+    description: text(node.description)
+  };
+  link(reader, [], base);
+  link(reader, ["name"], at("name"));
+  link(reader, ["description"], at("description"), true);
+  const image = readImage(reader, node.image, at("image"));
+  if (image) {
+    model.image = image.url;
+    link(reader, ["image"], image.source, true);
+  }
+  readYield(reader, model, node.recipeYield, at("recipeYield"));
+  const times = {};
+  for (const [key, field] of TIMES) {
+    const minutes = readTime(reader, node[field], at(field));
+    if (minutes !== void 0) {
+      times[key] = minutes;
+    }
+  }
+  model.times = times;
+  model.ingredients = readList(
+    reader,
+    "ingredients",
+    node.recipeIngredient,
+    at("recipeIngredient"),
+    readLine,
+    'an ingredient line such as "2 cups flour"'
+  );
+  model.steps = readList(
+    reader,
+    "steps",
+    node.recipeInstructions,
+    at("recipeInstructions"),
+    readStep,
+    'a step such as "Whisk the eggs." or a HowToStep'
+  );
+  model.equipment = readTools(reader, node.tool, at("tool"));
+  model.nutrition = readNutrition(reader, node.nutrition, at("nutrition"));
+  return model;
+}
+function readImage(reader, value, source) {
+  if (isAbsent(value)) {
+    return void 0;
+  }
+  const warnings = reader.warnings.length + reader.repeated;
+  const image = findImage(reader, value, source);
+  if (!image && reader.warnings.length + reader.repeated === warnings) {
+    ignore(
+      reader,
+      "invalid_type",
+      source,
+      `Expected an image URL, an ImageObject with a url, or a list of them, received ${describeValue(value)}.`
+    );
+  }
+  return image;
+}
+function findImage(reader, value, source, referenced = false) {
+  reader.deepest = Math.max(reader.deepest, source.length);
+  if (source.length > MAX_DEPTH) {
+    if (!isAbsent(value)) {
+      ignore(
+        reader,
+        "invalid_type",
+        source,
+        `Expected an image URL, an ImageObject with a url, or a list of them, received ${describeValue(value)} nested more than ${MAX_DEPTH} levels deep.`
+      );
+    }
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const url = cleanText(value);
+    const scheme = disallowedScheme(url);
+    if (scheme) {
+      ignore(
+        reader,
+        "invalid_url",
+        source,
+        `Expected an http or https URL, or a relative one, received ${quote(`${scheme}\u2026`)}.`
+      );
+      return void 0;
+    }
+    if (url.length > MAX_URL_LENGTH) {
+      ignore(
+        reader,
+        "invalid_url",
+        source,
+        `Expected a URL of at most ${MAX_URL_LENGTH} UTF-16 code units, received ${url.length}.`
+      );
+      return void 0;
+    }
+    return url ? { url, source } : void 0;
+  }
+  if (Array.isArray(value)) {
+    for (const [entry, entrySource] of entriesOf(value, source)) {
+      const image2 = findImage(reader, entry, entrySource, referenced);
+      if (image2) {
+        return image2;
+      }
+    }
+    return void 0;
+  }
+  const images = reader.images[referenced ? 1 : 0];
+  const reads = images.get(value) ?? [];
+  const read = reads.find(
+    ([, , depth, length]) => length === source.length || Math.max(length, source.length) + depth <= MAX_DEPTH
+  );
+  if (read) {
+    reader.repeated += read[1];
+    reader.deepest = Math.max(reader.deepest, source.length + read[2]);
+    return read[0];
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  images.set(value, reads);
+  const warnings = reader.warnings.length + reader.repeated;
+  const deepest = reader.deepest;
+  reader.deepest = source.length;
+  const id = record["@id"];
+  const target = typeof id === "string" && !referenced ? reader.ids.get(id) : void 0;
+  let image = findImage(reader, record.url, [...source, "url"], referenced) ?? findImage(reader, record.contentUrl, [...source, "contentUrl"], referenced);
+  if (!image && target?.node === reader.recipe) {
+    ignore(
+      reader,
+      "invalid_type",
+      source,
+      "Expected an image URL, an ImageObject with a url, or a list of them, received a reference to the recipe itself."
+    );
+  } else if (!image && target) {
+    image = findImage(reader, target.node, target.path, true);
+  }
+  reads.push([
+    image,
+    reader.warnings.length + reader.repeated - warnings,
+    reader.deepest - source.length,
+    source.length
+  ]);
+  reader.deepest = Math.max(reader.deepest, deepest);
+  return image;
+}
+function readYield(reader, model, value, source) {
+  const batches = entriesOf(value, source).flatMap(
+    ([entry, entrySource]) => (typeof entry === "string" ? entry.split(/,\s+/) : [entry]).map(
+      (part) => readBatch(reader, part, entrySource)
+    )
+  ).filter((batch) => batch !== void 0);
+  const yields = batches.filter((batch) => batch.yield !== void 0);
+  const servings = batches.filter((batch) => batch.servings !== void 0);
+  const kept = yields.find((batch) => !batch.article) ?? yields.find((batch) => batch.article);
+  const keptServings = servings.find((batch) => batch.worded) ?? servings.find((batch) => batch.amount !== kept?.amount);
+  for (const batch of servings) {
+    if (keptServings && batch.amount !== keptServings.amount && (batch.worded || batch.amount !== kept?.amount)) {
+      warning(
+        reader.warnings,
+        "ignored_value",
+        batch.source,
+        `Only one number of servings is read, ${quote(keptServings.label)}, so this one is ignored.`
+      );
+    }
+  }
+  for (const batch of yields) {
+    if (batch !== kept) {
+      warning(
+        reader.warnings,
+        "ignored_value",
+        batch.source,
+        `Only one yield is read, ${quote(kept.label)}, so this one is ignored.`
+      );
+    }
+  }
+  if (keptServings) {
+    model.servings = keptServings.servings;
+    link(reader, ["servings"], keptServings.source, true);
+  }
+  if (kept) {
+    model.yield = kept.yield;
+    link(reader, ["yield"], kept.source, true);
+  }
+}
+function readBatch(reader, value, source) {
+  if (typeof value === "number") {
+    return { source, label: String(value), amount: value, servings: value };
+  }
+  if (typeof value === "string") {
+    const label = cleanText(value);
+    if (!label) {
+      return void 0;
+    }
+    const text2 = label.replace(
+      /^(?:(?:serves|servings?|yields?|makes)\s*:?\s*)?(?:about\s+)?/i,
+      ""
+    );
+    const match = matchAmount(text2);
+    if (!match || "code" in match) {
+      ignore(
+        reader,
+        match?.code ?? "invalid_quantity",
+        source,
+        match?.message ?? `Expected a batch such as "24 cookies" or "3\u20134 loaves", received ${describeValue(label)}.`
+      );
+      return void 0;
+    }
+    const amount2 = typeof match.amount === "number" ? match.amount : match.amount.min;
+    const rest = match.rest.trim();
+    return !rest || SERVINGS_WORD.test(rest) ? { source, label, amount: amount2, servings: match.amountText, worded: !!rest } : { source, label, amount: amount2, yield: text2, article: /^an?\s/i.test(text2) };
+  }
+  const record = asRecord(value);
+  const amount = toNumber(record?.value ?? record?.minValue);
+  if (record && amount !== void 0) {
+    const max = toNumber(record.maxValue);
+    const unit = typeof record.unitText === "string" ? cleanText(record.unitText) : "";
+    const range = {
+      amount,
+      ...max !== void 0 && max !== amount && { max }
+    };
+    const label = `${amount}${max !== amount && max ? `\u2013${max}` : ""}${unit && ` ${unit}`}`;
+    return !unit || SERVINGS_WORD.test(unit) ? { source, label, amount, servings: range, worded: !!unit } : { source, label, amount, yield: { ...range, unit } };
+  }
+  if (!isAbsent(value)) {
+    ignore(
+      reader,
+      "invalid_type",
+      source,
+      `Expected a yield such as "4 servings" or "24 cookies", received ${describeValue(value)}.`
+    );
+  }
+  return void 0;
+}
+function readTime(reader, value, source) {
+  if (isAbsent(value)) {
+    return void 0;
+  }
+  const minutes = typeof value === "string" ? parseIsoDuration(cleanText(value)) : void 0;
+  if (minutes === void 0 || minutes > Number.MAX_SAFE_INTEGER) {
+    ignore(
+      reader,
+      "invalid_duration",
+      source,
+      `Expected an ISO 8601 duration such as "PT30M", received ${describeValue(value)}${minutes === void 0 ? "" : ", which is too long"}.`
+    );
+    return void 0;
+  }
+  return minutes > 0 ? minutes : void 0;
+}
+function readList(reader, key, value, source, readItem, expected) {
+  const list = [];
+  link(reader, [key], source);
+  const add = (items, path, entry, entrySource, inSection) => {
+    if (isAbsent(entry)) {
+      return;
+    }
+    if (entrySource.length > MAX_DEPTH) {
+      ignore(
+        reader,
+        "invalid_type",
+        entrySource,
+        `Expected ${expected}, received ${describeValue(entry)} nested more than ${MAX_DEPTH} levels deep.`
+      );
+      return;
+    }
+    if (Array.isArray(entry)) {
+      const elements2 = entriesOf(entry, entrySource);
+      const positions = elements2.map(
+        ([element]) => toNumber(asRecord(element)?.position)
+      );
+      const order = [...elements2.keys()];
+      if (!positions.includes(void 0)) {
+        order.sort((a, b) => positions[a] - positions[b]);
+      }
+      for (const i of order) {
+        const [element, elementSource] = elements2[i];
+        add(items, path, element, elementSource, inSection);
+      }
+      return;
+    }
+    const record = asRecord(entry);
+    const elements = [...entrySource, "itemListElement"];
+    if (record?.itemListElement !== void 0 && record.text === void 0) {
+      const title = typeof record.name === "string" ? cleanText(record.name) : "";
+      if (title && !inSection) {
+        const section = { title, items: [] };
+        const sectionPath = [key, list.length];
+        list.push(section);
+        link(reader, sectionPath, entrySource);
+        link(reader, [...sectionPath, "title"], [...entrySource, "name"]);
+        add(
+          section.items,
+          [...sectionPath, "items"],
+          record.itemListElement,
+          elements,
+          true
+        );
+      } else {
+        add(items, path, record.itemListElement, elements, inSection);
+      }
+      return;
+    }
+    if (record && !isAbsent(record.item)) {
+      add(items, path, record.item, [...entrySource, "item"], inSection);
+      return;
+    }
+    const read = readItem(reader, entry, entrySource);
+    if (!read) {
+      ignore(
+        reader,
+        "invalid_type",
+        entrySource,
+        `Expected ${expected}, received ${describeValue(entry)}.`
+      );
+      return;
+    }
+    for (const item of read) {
+      const itemPath = [...path, items.length];
+      items.push(item.value);
+      link(reader, itemPath, item.source, true);
+      for (const [field, fieldSource, droppable] of item.fields) {
+        link(reader, [...itemPath, field], fieldSource, droppable);
+      }
+    }
+  };
+  add(list, [key], value, source, false);
+  return list;
+}
+function readLine(reader, value, source) {
+  if (typeof value === "string") {
+    return cleanLines(value).map((line) => ({
+      value: line,
+      source,
+      fields: []
+    }));
+  }
+  const record = asRecord(value);
+  const parts = [record?.value, record?.unitText, record?.name ?? record?.text].filter((part) => typeof part === "string" || typeof part === "number").join(" ");
+  return parts ? cleanLines(parts).map((line) => ({ value: line, source, fields: [] })) : void 0;
+}
+function readStep(reader, value, source) {
+  if (typeof value === "string") {
+    return cleanLines(value).map((line) => ({
+      value: line,
+      source,
+      fields: []
+    }));
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const name = typeof record.name === "string" ? cleanText(record.name) : "";
+  const body = text(record.text) ?? name;
+  const image = readImage(reader, record.image, [...source, "image"]);
+  const lead = name.replace(/(?:…|\.\.\.)$/, "").trim();
+  const hasName = typeof body === "string" && !body.startsWith(lead) && !/^step\s*\d*[.:]?$/i.test(name);
+  const fields = [
+    ["text", [...source, name && body === name ? "name" : "text"], false]
+  ];
+  if (image) {
+    fields.push(["image", image.source, true]);
+  }
+  return [
+    {
+      value: {
+        text: body,
+        ...hasName && { name },
+        ...image && { image: image.url }
+      },
+      source,
+      fields
+    }
+  ];
+}
+function readTools(reader, value, source) {
+  const equipment = [];
+  link(reader, ["equipment"], source);
+  for (const [entry, entrySource] of entriesOf(value, source)) {
+    const record = asRecord(entry);
+    const item = record ? {
+      name: text(record.name),
+      ...record.requiredQuantity !== void 0 && {
+        quantity: toNumber(
+          asRecord(record.requiredQuantity)?.value ?? record.requiredQuantity
+        ) ?? record.requiredQuantity
+      },
+      ...record.url !== void 0 && { url: text(record.url) }
+    } : text(entry);
+    if (item === void 0) {
+      continue;
+    }
+    const path = ["equipment", equipment.length];
+    equipment.push(item);
+    link(reader, path, entrySource, true);
+    link(reader, [...path, "name"], [...entrySource, "name"]);
+    link(
+      reader,
+      [...path, "quantity"],
+      [...entrySource, "requiredQuantity"],
+      true
+    );
+    link(reader, [...path, "url"], [...entrySource, "url"], true);
+  }
+  return equipment;
+}
+function readNutrition(reader, value, source) {
+  link(reader, ["nutrition"], source);
+  if (isAbsent(value)) {
+    return void 0;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    ignore(
+      reader,
+      "invalid_type",
+      source,
+      `Expected NutritionInformation, such as { "calories": "250 kcal" }, received ${describeValue(value)}.`
+    );
+    return void 0;
+  }
+  const nutrition = {};
+  const keys = Object.keys(NUTRIENTS);
+  for (const [field, amount] of Object.entries(record)) {
+    const key = keys.find((key2) => NUTRIENTS[key2] === field);
+    if (key) {
+      nutrition[key] = text(amount);
+      link(reader, ["nutrition", key], [...source, field], true);
+    } else if (!field.startsWith("@")) {
+      ignore(reader, "unknown_field", [...source, field], "Unknown field.");
+    }
+  }
+  return nutrition;
+}
+function text(value) {
+  return typeof value === "string" ? cleanText(value) || void 0 : value ?? void 0;
+}
+function toNumber(value) {
+  const number = typeof value === "string" && value.trim() ? Number(value) : value;
+  return typeof number === "number" && Number.isFinite(number) ? number : void 0;
+}
+function isAbsent(value) {
+  return value === void 0 || value === null || typeof value === "string" && !value.trim();
+}
+function ignore(reader, code, path, message) {
+  warning(reader.warnings, code, path, `${message} It is ignored.`);
+}
+function link(reader, path, source, droppable = false) {
+  const key = JSON.stringify(path);
+  reader.sources.set(key, source);
+  if (droppable) {
+    reader.droppable.add(key);
+  }
+}
+function sourceOf(reader, path) {
+  for (let n = path.length; n >= 0; n--) {
+    const source = reader.sources.get(JSON.stringify(path.slice(0, n)));
+    if (source) {
+      return source;
+    }
+  }
+  return [];
+}
+function compareOrder(a, b) {
+  for (const [i, n] of a.entries()) {
+    if (i === b.length) {
+      return 1;
+    }
+    const m = b[i];
+    if (n !== m) {
+      return n - m;
+    }
+  }
+  return a.length - b.length;
+}
+function droppableAt(reader, path) {
+  for (let n = path.length; n > 0; n--) {
+    const at = path.slice(0, n);
+    if (reader.droppable.has(JSON.stringify(at))) {
+      return at;
+    }
+  }
+  return void 0;
+}
+function remove(model, path) {
+  const parent = path.slice(0, -1).reduce(
+    (value, key) => value?.[key],
+    model
+  );
+  if (parent) {
+    delete parent[path[path.length - 1]];
+  }
+}
+export {
+  fromJsonLd
+};
+//# sourceMappingURL=from-json-ld.js.map