@4kk11/cooklang-sankey 0.1.0

package/README.md

@@ -0,0 +1,161 @@
+# cooklang-sankey
+
+Generate Sankey diagram data from Cooklang recipes.
+
+## Installation
+
+```bash
+npm install cooklang-sankey
+```
+
+## Usage
+
+### Browser Environment
+
+```typescript
+import { CooklangParser, generateSankeyData, optimizeSankeyData } from 'cooklang-sankey';
+
+// Create a parser instance
+const parser = new CooklangParser();
+
+// Your Cooklang recipe text
+const recipeText = `
+---
+title: カルボナーラ
+servings: 2
+---
+
+@パスタ{200g}を茹でる。
+@卵{2個}と@パルメザンチーズ{50g}を混ぜる。
+@ベーコン{100g}を炒める。
+パスタとソースを合わせて完成。
+`;
+
+// Parse the recipe text
+const [recipe] = parser.parse(recipeText);
+
+// Generate Sankey data from parsed recipe
+const data = generateSankeyData(recipe, {
+  finalNodeName: "完成品",
+  normalization: "logarithmic",
+});
+
+// Optionally optimize the data
+const optimized = data ? optimizeSankeyData(data) : null;
+
+console.log(optimized);
+```
+
+### Node.js Environment
+
+```typescript
+import { CooklangParser, generateSankeyData, optimizeSankeyData } from 'cooklang-sankey';
+
+// Create parser instance
+const parser = new CooklangParser();
+
+const recipeText = `
+@パスタ{200g}を茹でる。
+@卵{2個}と@パルメザンチーズ{50g}を混ぜる。
+`;
+
+// Parse the recipe text
+const [recipe] = parser.parse(recipeText);
+
+// Generate Sankey data from parsed recipe
+const data = generateSankeyData(recipe);
+const optimized = data ? optimizeSankeyData(data) : null;
+
+console.log(JSON.stringify(optimized, null, 2));
+```
+
+### API
+
+#### `generateSankeyData(recipe, options?)`
+
+Generates Sankey diagram data from a parsed Cooklang recipe.
+
+**Parameters:**
+- `recipe: CooklangRecipe` - Parsed Cooklang recipe object
+- `options?: SankeyGeneratorOptions`
+  - `finalNodeName?: string` - Name for the final node (default: "完成品")
+  - `normalization?: "logarithmic" | "linear" | "none"` - Value normalization method
+  - `minLinkValue?: number` - Minimum link value (default: 0.1)
+
+**Returns:** `SankeyData | null`
+
+#### `optimizeSankeyData(data)`
+
+Validates and optimizes Sankey data by removing invalid links and orphaned nodes.
+
+**Returns:** `SankeyData`
+
+### Types
+
+```typescript
+interface SankeyData {
+  nodes: SankeyNode[];
+  links: SankeyLink[];
+}
+
+interface SankeyNode {
+  id: string;
+  name: string;
+  category: "ingredient" | "process" | "final";
+  value: number;
+  label: string;
+  originalValue?: number;
+  metadata?: BaseNodeMetadata;
+}
+
+interface SankeyLink {
+  source: string;
+  target: string;
+  value: number;
+  originalValue?: number;
+  metadata?: BaseLinkMetadata;
+}
+```
+
+## React Integration
+
+For React applications, we recommend creating custom hooks:
+
+```typescript
+import { useMemo } from 'react';
+import {
+  CooklangParser,
+  generateSankeyData,
+  optimizeSankeyData,
+  type CooklangRecipe
+} from 'cooklang-sankey';
+
+// Create a singleton parser instance
+const parser = new CooklangParser();
+
+export function useSankeyData(recipeText: string) {
+  return useMemo(() => {
+    if (!recipeText) return null;
+
+    // Parse the recipe text
+    const [recipe] = parser.parse(recipeText);
+
+    // Generate Sankey data from parsed recipe
+    const data = generateSankeyData(recipe);
+    return data ? optimizeSankeyData(data) : null;
+  }, [recipeText]);
+}
+
+// Or if you already have a parsed recipe:
+export function useSankeyDataFromRecipe(recipe: CooklangRecipe | null) {
+  return useMemo(() => {
+    if (!recipe) return null;
+    const data = generateSankeyData(recipe);
+    return data ? optimizeSankeyData(data) : null;
+  }, [recipe]);
+}
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,492 @@
+'use strict';
+
+var cooklang = require('@cooklang/cooklang');
+var toposort = require('toposort');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var toposort__default = /*#__PURE__*/_interopDefault(toposort);
+
+// src/parser.ts
+function extractMetadata(recipe) {
+  const result = {};
+  if (recipe.title) {
+    result.title = recipe.title;
+  }
+  if (recipe.description) {
+    result.description = recipe.description;
+  }
+  if (recipe.tags && recipe.tags.size > 0) {
+    result.tags = Array.from(recipe.tags);
+  }
+  if (recipe.time) {
+    const timeValue = recipe.time;
+    if (typeof timeValue === "object" && timeValue !== null) {
+      const parts = [];
+      if ("prep_time" in timeValue && timeValue.prep_time) {
+        parts.push(`prep: ${timeValue.prep_time}`);
+      }
+      if ("cook_time" in timeValue && timeValue.cook_time) {
+        parts.push(`cook: ${timeValue.cook_time}`);
+      }
+      if ("total_time" in timeValue && timeValue.total_time) {
+        parts.push(`total: ${timeValue.total_time}`);
+      }
+      if (parts.length > 0) {
+        result.cookingTime = parts.join(", ");
+      }
+    }
+  }
+  if (recipe.servings) {
+    const servings = recipe.servings;
+    if (Array.isArray(servings)) {
+      result.servings = servings.join("-");
+    } else if (typeof servings === "object" && servings !== null) {
+      result.servings = String(servings);
+    }
+  }
+  if (recipe.custom_metadata && recipe.custom_metadata.size > 0) {
+    for (const [key, value] of recipe.custom_metadata) {
+      if (!(key in result)) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/constants.ts
+var NORMALIZATION = {
+  /** Minimum normalized value for logarithmic scale */
+  LOG_MIN: 0.1,
+  /** Maximum normalized value for logarithmic scale */
+  LOG_MAX: 0.3,
+  /** Minimum normalized value for linear scale */
+  LINEAR_MIN: 0.1,
+  /** Range for linear normalization */
+  LINEAR_RANGE: 0.2,
+  /** Default value when normalization range is zero */
+  DEFAULT_VALUE: 1
+};
+var DEFAULT_FINAL_NODE_NAME = "\u5B8C\u6210\u54C1";
+var DEFAULT_MIN_LINK_VALUE = 0.1;
+var DEFAULT_NORMALIZATION = "logarithmic";
+var FINAL_NODE_ID = "final_dish";
+var DEFAULT_SECTION_NAME = "main";
+
+// src/sankey/normalizer.ts
+var normalizeIngredientValues = (ingredientNodes, normalization) => {
+  const result = /* @__PURE__ */ new Map();
+  if (normalization === "none") {
+    ingredientNodes.forEach((node) => {
+      result.set(node.id, node.value || NORMALIZATION.DEFAULT_VALUE);
+    });
+    return result;
+  }
+  const nodeValues = ingredientNodes.map((n) => n.value || NORMALIZATION.DEFAULT_VALUE);
+  const minValue = Math.min(...nodeValues);
+  const maxValue = Math.max(...nodeValues);
+  const valueRange = maxValue - minValue;
+  const normalizeValue = (value) => {
+    if (valueRange === 0) return NORMALIZATION.DEFAULT_VALUE;
+    if (normalization === "logarithmic") {
+      const normalizedLinear = (value - minValue) / valueRange;
+      const logScale = Math.log10(1 + normalizedLinear * 9);
+      return Math.min(Math.max(NORMALIZATION.LOG_MIN, logScale), NORMALIZATION.LOG_MAX);
+    } else {
+      return NORMALIZATION.LINEAR_MIN + (value - minValue) / valueRange * NORMALIZATION.LINEAR_RANGE;
+    }
+  };
+  ingredientNodes.forEach((node) => {
+    result.set(node.id, node.value ? normalizeValue(node.value) : NORMALIZATION.DEFAULT_VALUE);
+  });
+  return result;
+};
+var buildDAGAndSort = (nodes, edges) => {
+  const edgePairs = edges.map((edge) => [edge.from, edge.to]);
+  try {
+    return toposort__default.default(edgePairs);
+  } catch (error) {
+    console.error("Cycle detected in DAG:", error);
+    return nodes.map((node) => node.id);
+  }
+};
+var calculateNodeValues = (nodes, sortedNodeIds) => {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const valueMap = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => {
+    nodeMap.set(node.id, node);
+    if (node.category === "ingredient") {
+      valueMap.set(node.id, node.value);
+    } else {
+      valueMap.set(node.id, 0);
+    }
+  });
+  for (const nodeId of sortedNodeIds) {
+    const node = nodeMap.get(nodeId);
+    if (!node) continue;
+    if (node.category === "ingredient") {
+      continue;
+    }
+    let totalInputValue = 0;
+    for (const inputId of node.inputs) {
+      let inputValue = valueMap.get(inputId) || 0;
+      const inputNode = nodeMap.get(inputId);
+      if (inputNode && inputNode.outputs.length > 1) {
+        inputValue /= inputNode.outputs.length;
+      }
+      totalInputValue += inputValue;
+    }
+    valueMap.set(nodeId, totalInputValue);
+  }
+  return valueMap;
+};
+var formatValue = (value) => {
+  if (!value) return "";
+  if (value.type === "number") {
+    const num = cooklang.getNumericValue(value);
+    return num !== null ? num.toString() : "";
+  } else if (value.type === "range") {
+    const rangeValue = value.value;
+    const startNum = cooklang.getNumericValue({ type: "number", value: rangeValue.start });
+    const endNum = cooklang.getNumericValue({ type: "number", value: rangeValue.end });
+    if (startNum !== null && endNum !== null) {
+      return `${startNum}-${endNum}`;
+    }
+    return "";
+  } else if (value.type === "text") {
+    return value.value;
+  }
+  return "";
+};
+var formatQuantityAmount = (quantity) => {
+  if (!quantity) {
+    return { quantity: "", unit: "" };
+  }
+  return {
+    quantity: formatValue(quantity.value),
+    unit: quantity.unit || ""
+  };
+};
+var generateStepText = (step, recipe) => {
+  return step.items.map((item) => {
+    if (item.type === "text") {
+      return item.value;
+    } else if (item.type === "ingredient") {
+      const originalIngredient = recipe.ingredients[item.index];
+      if (!originalIngredient) return "";
+      const formatted = formatQuantityAmount(originalIngredient.quantity);
+      const quantityText = formatted.quantity && formatted.unit ? `(${formatted.quantity}${formatted.unit})` : formatted.quantity ? `(${formatted.quantity})` : "";
+      return `${originalIngredient.name}${quantityText}`;
+    } else if (item.type === "cookware") {
+      return recipe.cookware[item.index]?.name || "";
+    } else if (item.type === "timer") {
+      const timer = recipe.timers[item.index];
+      if (!timer) return "";
+      return timer.name || (timer.quantity ? cooklang.quantity_display(timer.quantity) : "");
+    }
+    return "";
+  }).join("");
+};
+
+// src/sankey/node-builders.ts
+var calculateIngredientQuantity = (groupedQuantity) => {
+  if (cooklang.grouped_quantity_is_empty(groupedQuantity)) {
+    return { type: "text", label: "unknown" };
+  }
+  const displayText = cooklang.grouped_quantity_display(groupedQuantity);
+  const gq = groupedQuantity;
+  const quantityToUse = gq.fixed || gq.scalable || gq.fixed_unknown || gq.scalable_unknown;
+  if (quantityToUse) {
+    const numericValue = cooklang.getNumericValue(quantityToUse.value);
+    if (numericValue !== null) {
+      return { type: "number", value: numericValue, label: displayText || `${numericValue}` };
+    }
+  }
+  return { type: "text", label: displayText || "unknown" };
+};
+var createIngredientNodes = (recipe) => {
+  const nodes = [];
+  const indexMap = /* @__PURE__ */ new Map();
+  recipe.groupedIngredients.forEach(([ingredient, groupedQuantity], index) => {
+    const extracted = calculateIngredientQuantity(groupedQuantity);
+    const value = extracted.type === "number" ? extracted.value : 1;
+    const label = extracted.label;
+    const ingredientId = index.toString();
+    indexMap.set(index, ingredientId);
+    nodes.push({
+      id: ingredientId,
+      name: ingredient.name,
+      category: "ingredient",
+      value,
+      originalValue: value,
+      label,
+      inputs: [],
+      outputs: [],
+      metadata: {
+        originalIndex: index
+      }
+    });
+  });
+  return { nodes, indexMap };
+};
+var createStepNodes = (recipe) => {
+  const nodes = [];
+  for (const section of recipe.sections) {
+    for (const content of section.content) {
+      if (content.type === "step") {
+        const step = content.value;
+        const stepText = generateStepText(step, recipe);
+        const stepId = `step_${section.name || DEFAULT_SECTION_NAME}_${step.number}`;
+        nodes.push({
+          id: stepId,
+          name: stepText || `\u624B\u9806 ${step.number}`,
+          category: "process",
+          value: 0,
+          label: `${step.number}`,
+          inputs: [],
+          outputs: [],
+          metadata: {
+            stepNumber: step.number,
+            sectionName: section.name || void 0
+          }
+        });
+      }
+    }
+  }
+  return nodes;
+};
+var createFinalNode = (finalNodeName) => ({
+  id: FINAL_NODE_ID,
+  name: finalNodeName,
+  category: "final",
+  value: 0,
+  label: "",
+  inputs: [],
+  outputs: []
+});
+
+// src/sankey/edge-builders.ts
+var getStepId = (sectionName, stepNumber) => {
+  return `step_${sectionName || DEFAULT_SECTION_NAME}_${stepNumber}`;
+};
+var extractIngredientUsageFromStep = (step) => {
+  const usages = [];
+  for (const item of step.items) {
+    if (item.type === "ingredient") {
+      usages.push({
+        ingredientIndex: item.index,
+        stepNumber: step.number
+      });
+    }
+  }
+  return usages;
+};
+var buildIngredientToStepEdges = (recipe, ingredientIndexMap, nodes) => {
+  const edges = [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => nodeMap.set(node.id, node));
+  for (const section of recipe.sections) {
+    for (const content of section.content) {
+      if (content.type === "step") {
+        const step = content.value;
+        const currentStepId = getStepId(section.name, step.number);
+        const usedIngredients = extractIngredientUsageFromStep(step);
+        for (const usage of usedIngredients) {
+          const ingredient = recipe.ingredients[usage.ingredientIndex];
+          const relation = ingredient.relation;
+          if (relation && relation.relation?.type === "reference" && relation.reference_target === "step") {
+            const referenceTo = relation.relation.references_to;
+            const sourceStepId = getStepId(section.name, referenceTo + 1);
+            edges.push({
+              from: sourceStepId,
+              to: currentStepId,
+              metadata: {
+                stepNumber: step.number,
+                transformationType: "cooking"
+              }
+            });
+            const sourceNode = nodeMap.get(sourceStepId);
+            const targetNode = nodeMap.get(currentStepId);
+            if (sourceNode && targetNode) {
+              sourceNode.outputs.push(currentStepId);
+              targetNode.inputs.push(sourceStepId);
+            }
+            continue;
+          }
+          const ingredientId = ingredientIndexMap.get(usage.ingredientIndex);
+          if (ingredientId) {
+            edges.push({
+              from: ingredientId,
+              to: currentStepId,
+              metadata: {
+                stepNumber: step.number,
+                transformationType: "preparation"
+              }
+            });
+            const ingredientNode = nodeMap.get(ingredientId);
+            const stepNode = nodeMap.get(currentStepId);
+            if (ingredientNode && stepNode) {
+              ingredientNode.outputs.push(currentStepId);
+              stepNode.inputs.push(ingredientId);
+            }
+          }
+        }
+      }
+    }
+  }
+  return edges;
+};
+var buildStepToFinalEdges = (stepNodes, finalNode) => {
+  if (stepNodes.length === 0) return [];
+  const lastStepNode = stepNodes[stepNodes.length - 1];
+  lastStepNode.outputs.push(finalNode.id);
+  finalNode.inputs.push(lastStepNode.id);
+  return [
+    {
+      from: lastStepNode.id,
+      to: finalNode.id,
+      metadata: {
+        transformationType: "completion"
+      }
+    }
+  ];
+};
+
+// src/sankey/generator.ts
+var DEFAULT_OPTIONS = {
+  finalNodeName: DEFAULT_FINAL_NODE_NAME,
+  normalization: DEFAULT_NORMALIZATION,
+  minLinkValue: DEFAULT_MIN_LINK_VALUE
+};
+var buildSankeyData = (dagNodes, dagEdges, sortedNodeIds, options) => {
+  const ingredientNodes = dagNodes.filter((node) => node.category === "ingredient").map((node) => ({
+    id: node.id,
+    name: node.name,
+    category: node.category,
+    value: node.value,
+    label: node.label,
+    originalValue: node.originalValue,
+    metadata: node.metadata
+  }));
+  const normalizedValueMap = normalizeIngredientValues(ingredientNodes, options.normalization);
+  const normalizedDAGNodes = dagNodes.map((node) => {
+    if (node.category === "ingredient") {
+      return {
+        ...node,
+        value: normalizedValueMap.get(node.id) ?? node.value
+      };
+    }
+    return node;
+  });
+  const finalCalculatedValues = calculateNodeValues(normalizedDAGNodes, sortedNodeIds);
+  const sankeyNodes = dagNodes.map((dagNode) => {
+    const finalValue = finalCalculatedValues.get(dagNode.id) || 0;
+    return {
+      id: dagNode.id,
+      name: dagNode.name,
+      category: dagNode.category,
+      value: dagNode.category === "ingredient" ? normalizedValueMap.get(dagNode.id) ?? dagNode.value : finalValue,
+      label: dagNode.label,
+      originalValue: dagNode.originalValue,
+      metadata: dagNode.metadata
+    };
+  });
+  const sankeyLinks = dagEdges.map((edge) => {
+    const sourceValue = finalCalculatedValues.get(edge.from) || 0;
+    const sourceNode = dagNodes.find((n) => n.id === edge.from);
+    let linkValue = sourceValue;
+    if (sourceNode && sourceNode.outputs.length > 1) {
+      linkValue = sourceValue / sourceNode.outputs.length;
+    }
+    return {
+      source: edge.from,
+      target: edge.to,
+      value: Math.max(options.minLinkValue, linkValue),
+      originalValue: sourceValue,
+      metadata: edge.metadata
+    };
+  });
+  return {
+    nodes: sankeyNodes,
+    links: sankeyLinks
+  };
+};
+var generateSankeyData = (recipe, options) => {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  try {
+    const { nodes: ingredientNodes, indexMap: ingredientIndexMap } = createIngredientNodes(recipe);
+    const stepNodes = createStepNodes(recipe);
+    const finalNode = createFinalNode(opts.finalNodeName);
+    const allNodes = [...ingredientNodes, ...stepNodes, finalNode];
+    const ingredientToStepEdges = buildIngredientToStepEdges(recipe, ingredientIndexMap, allNodes);
+    const stepToFinalEdges = buildStepToFinalEdges(stepNodes, finalNode);
+    const allEdges = [...ingredientToStepEdges, ...stepToFinalEdges];
+    const sortedNodeIds = buildDAGAndSort(allNodes, allEdges);
+    return buildSankeyData(allNodes, allEdges, sortedNodeIds, opts);
+  } catch (error) {
+    console.error("Error generating sankey data from cooklang:", error);
+    return null;
+  }
+};
+var optimizeSankeyData = (data) => {
+  const existingNodeIds = new Set(data.nodes.map((node) => node.id));
+  const validLinks = data.links.filter((link) => {
+    const sourceExists = existingNodeIds.has(link.source);
+    const targetExists = existingNodeIds.has(link.target);
+    if (!sourceExists) {
+      console.error(`Missing source node: ${link.source}`);
+    }
+    if (!targetExists) {
+      console.error(`Missing target node: ${link.target}`);
+    }
+    return sourceExists && targetExists;
+  });
+  const connectedNodeIds = /* @__PURE__ */ new Set();
+  validLinks.forEach((link) => {
+    connectedNodeIds.add(link.source);
+    connectedNodeIds.add(link.target);
+  });
+  const filteredNodes = data.nodes.filter(
+    (node) => connectedNodeIds.has(node.id) || node.category === "final"
+  );
+  let normalizedLinks = validLinks;
+  if (validLinks.length > 0) {
+    const minValue = Math.min(...validLinks.map((link) => link.value));
+    if (minValue > 0) {
+      normalizedLinks = validLinks.map((link) => ({
+        ...link,
+        value: Math.max(1, link.value / minValue)
+      }));
+    }
+  }
+  return {
+    nodes: filteredNodes,
+    links: normalizedLinks
+  };
+};
+
+Object.defineProperty(exports, "CooklangParser", {
+  enumerable: true,
+  get: function () { return cooklang.CooklangParser; }
+});
+Object.defineProperty(exports, "CooklangRecipe", {
+  enumerable: true,
+  get: function () { return cooklang.CooklangRecipe; }
+});
+Object.defineProperty(exports, "getNumericValue", {
+  enumerable: true,
+  get: function () { return cooklang.getNumericValue; }
+});
+Object.defineProperty(exports, "quantity_display", {
+  enumerable: true,
+  get: function () { return cooklang.quantity_display; }
+});
+exports.extractMetadata = extractMetadata;
+exports.formatQuantityAmount = formatQuantityAmount;
+exports.formatValue = formatValue;
+exports.generateSankeyData = generateSankeyData;
+exports.generateStepText = generateStepText;
+exports.optimizeSankeyData = optimizeSankeyData;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map