@jclind/ingredient-parser 1.0.36 → 1.0.38

package/decs.d.ts

@@ -0,0 +1,2 @@
+declare module 'recipe-ingredient-parser-v3'
+declare module 'react-native-uuid'

package/dist/api/requests.d.ts

@@ -1,4 +1,4 @@
-import { IngredientData } from '../../index.js';
+import { IngredientData } from '@jclind/ingredient-parser';
 export declare const checkIngredient: (name: string) => Promise<import("axios").AxiosResponse<any, any>>;
 export declare const searchIngredient: (name: string, spoonacularAPIKey: string) => Promise<any>;
 export declare const getIngredientInformation: (ingrId: number, unit: boolean, spoonacularAPIKey: string) => Promise<any>;

package/dist/funcs/ingredientParser.d.ts

@@ -1,3 +1,3 @@
-import { IngredientResponse } from '../../index.js';
+import { IngredientResponse } from '@jclind/ingredient-parser';
 declare const ingredientParser: (ingrString: string, spoonacularAPIKey: string) => Promise<IngredientResponse>;
 export default ingredientParser;

package/dist/funcs/parseIngredientString.d.ts

@@ -1,2 +1,2 @@
-import { ParsedIngredient } from '../../index.js';
+import { ParsedIngredient } from '@jclind/ingredient-parser';
 export declare const parseIngredientString: (ingrStr: string) => ParsedIngredient;

package/dist/funcs/parseIngredientString.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseIngredientString = void 0;
 const recipe_ingredient_parser_v3_1 = require("recipe-ingredient-parser-v3");
+// import { ParsedIngredient } from '../../index.js'
 const convertFractions_js_1 = require("./convertFractions.js");
 const parseIngredientString = (ingrStr) => {
     var _a, _b;

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-import ingredientParser from './funcs/ingredientParser.js';
-import { ParsedIngredient as ParsedIngredientType, IngredientData as IngredientDataType, IngredientResponse as IngredientResponseType } from '../index.js';
-export { ingredientParser, ParsedIngredientType, IngredientDataType, IngredientResponseType, };
+export * from './funcs/ingredientParser';
+export * from '@jclind/ingredient-parser';

package/dist/index.js

@@ -1,5 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ingredientParser = void 0;
-const ingredientParser_js_1 = require("./funcs/ingredientParser.js");
-exports.ingredientParser = ingredientParser_js_1.default;
+__exportStar(require("./funcs/ingredientParser"), exports);
+__exportStar(require("@jclind/ingredient-parser"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jclind/ingredient-parser",
-  "version": "1.0.36",
-  "description": "Parses given sentence including ingredient information and attemps to return quantity, measurement and ingredient data",
+  "version": "1.0.38",
+  "description": "Parses given sentence including ingredient information and attempts to return quantity, measurement and ingredient data",
   "keywords": [
     "recipe",
     "ingredient",
@@ -9,13 +9,8 @@
     "units"
   ],
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "typings": "dist/index.d.ts",
+  "types": "types/index.d.ts",
   "type": "module",
-  "files": [
-    "dist",
-    "types.js"
-  ],
   "scripts": {
     "build": "tsc"
   },

package/src/api/http.ts

@@ -0,0 +1,15 @@
+import axios from 'axios'
+
+export const mongoHttp = axios.create({
+  baseURL:
+    'https://us-east-1.aws.data.mongodb-api.com/app/prepify-ixumn/endpoint',
+  headers: {
+    'Content-type': 'application/json',
+  },
+})
+export const spoonacularHttp = axios.create({
+  baseURL: 'https://api.spoonacular.com/food/ingredients/',
+  headers: {
+    'Content-type': 'application/json',
+  },
+})

package/src/api/requests.ts

@@ -0,0 +1,50 @@
+import { mongoHttp, spoonacularHttp } from './http.js'
+import { IngredientData } from '@jclind/ingredient-parser'
+export const checkIngredient = async (name: string) => {
+  return await mongoHttp.get(`checkIngredient?name=${name}`)
+}
+export const searchIngredient = async (
+  name: string,
+  spoonacularAPIKey: string
+) => {
+  let searchedIngr: any
+  try {
+    searchedIngr = await spoonacularHttp.get(
+      `search?query=${name}&number=1&apiKey=${spoonacularAPIKey}`
+    )
+  } catch (error: any) {
+    const res: any = error.response.data
+    if (res.code === 401) {
+      throw new Error('API Key Not Valid')
+    } else {
+      throw new Error('Error Occurred, Please Try Again')
+    }
+  }
+  return searchedIngr
+}
+export const getIngredientInformation = async (
+  ingrId: number,
+  unit: boolean,
+  spoonacularAPIKey: string
+) => {
+  let ingrData: any
+  try {
+    ingrData = await spoonacularHttp.get(
+      `${ingrId}/information?amount=1&${
+        unit ? 'unit=grams&' : ''
+      }apiKey=${spoonacularAPIKey}`
+    )
+  } catch (error: any) {
+    const res: any = error.response.data
+    if (res.code === 401) {
+      throw new Error('API Key Not Valid')
+    } else {
+      throw new Error('Error Occurred, Please Try Again')
+    }
+  }
+
+  return ingrData
+}
+export const setMongoDBIngrData = async (data: IngredientData) => {
+  return await mongoHttp.post(`addIngredient`, data)
+}

package/src/funcs/calculatePrice.ts

@@ -0,0 +1,25 @@
+//@ts-ignore
+import { converter } from '@jclind/ingredient-unit-converter'
+
+export const calculatePrice = (
+  quantity: number | null,
+  unit: string | null,
+  price: { estimatedSingleUnitPrice: number; estimatedGramPrice: number }
+): number | null => {
+  if (!quantity) return price.estimatedSingleUnitPrice
+  if (!unit) return price.estimatedSingleUnitPrice * quantity
+
+  let convertedUnit
+  try {
+    convertedUnit = converter(quantity, unit)
+  } catch (error) {
+    return null
+  }
+
+  if (!convertedUnit || convertedUnit.error)
+    return price.estimatedSingleUnitPrice * quantity
+
+  const convertedGrams = Number(convertedUnit.quantity)
+  const total: number = convertedGrams * price.estimatedGramPrice
+  return Math.ceil(total * 100) / 100
+}

package/src/funcs/convertFractions.ts

@@ -0,0 +1,29 @@
+export const convertFractions = (str: string): string => {
+  const fractions = {
+    '¼': '1/4',
+    '½': '1/2',
+    '¾': '3/4',
+    '⅓': '1/3',
+    '⅔': '2/3',
+    '⅛': '1/8',
+    '⅜': '3/8',
+    '⅝': '5/8',
+    '⅞': '7/8',
+    '⅕': '1/5',
+    '⅖': '2/5',
+    '⅗': '3/5',
+    '⅘': '4/5',
+    '⅙': '1/6',
+    '⅚': '5/6',
+    '⅐': '1/7',
+    '⅑': '1/9',
+    '⅒': '1/10',
+  }
+
+  for (const [fraction, value] of Object.entries(fractions)) {
+    const re = new RegExp(fraction, 'g')
+    str = str.replace(re, value)
+  }
+
+  return str
+}

package/src/funcs/getIngredientInfo.ts

@@ -0,0 +1,20 @@
+import { checkIngredient } from '../api/requests.js'
+import { getSpoonacularIngrData } from './getSpoonacularIngrData.js'
+
+export async function getIngredientInfo(
+  ingrName: string,
+  spoonacularAPIKey: string
+) {
+  const ingrNameLower = ingrName.toLowerCase()
+  if (!ingrNameLower) throw new Error('Ingredient Invalid')
+  const mongoIngrData = await checkIngredient(ingrNameLower)
+  if (!mongoIngrData.data) {
+    const ingrData = await getSpoonacularIngrData(
+      ingrNameLower,
+      spoonacularAPIKey
+    )
+    return ingrData
+  } else {
+    return mongoIngrData.data
+  }
+}

package/src/funcs/getSpoonacularIngrData.ts

@@ -0,0 +1,44 @@
+import {
+  getIngredientInformation,
+  searchIngredient,
+  setMongoDBIngrData,
+} from '../api/requests.js'
+
+export async function getSpoonacularIngrData(
+  name: string,
+  spoonacularAPIKey: string
+) {
+  const searchedIngr = await searchIngredient(name, spoonacularAPIKey)
+  if (searchedIngr.error) return searchedIngr
+  const ingrId = searchedIngr?.data?.results[0]?.id ?? null
+
+  if (!ingrId) throw new Error(`No Data Found, unknown ingredient: ${name}`)
+
+  const ingrDataGram = await getIngredientInformation(
+    ingrId,
+    true,
+    spoonacularAPIKey
+  )
+  const ingrDataSingleUnit = await getIngredientInformation(
+    ingrId,
+    false,
+    spoonacularAPIKey
+  )
+
+  if (ingrDataGram.error || ingrDataSingleUnit.error) return ingrDataGram
+
+  const estimatedGramPrice = ingrDataGram.data.estimatedCost.value
+  const estimatedSingleUnitPrice = ingrDataSingleUnit.data.estimatedCost.value
+
+  const ingrData = {
+    ...ingrDataGram.data,
+    name,
+    ingredientId: ingrId,
+    estimatedPrices: { estimatedGramPrice, estimatedSingleUnitPrice },
+  }
+
+  const mongoDBIngrData = ingrData
+  const mongoRes = await setMongoDBIngrData(mongoDBIngrData)
+  const _id = mongoRes.data.insertedId
+  return { ...mongoDBIngrData, _id }
+}

package/src/funcs/ingredientParser.ts

@@ -0,0 +1,72 @@
+import { calculatePrice } from './calculatePrice.js'
+import { parseIngredientString } from './parseIngredientString.js'
+import { getIngredientInfo } from './getIngredientInfo.js'
+import {
+  IngredientResponse,
+  ParsedIngredient,
+  IngredientData,
+} from '@jclind/ingredient-parser'
+
+const ingredientParser = async (
+  ingrString: string,
+  spoonacularAPIKey: string
+): Promise<IngredientResponse> => {
+  // const parsedIngr: ParsedIngredient = parse(ingrString, 'eng')
+  const parsedIngr: ParsedIngredient = parseIngredientString(ingrString)
+
+  let ingrData = null
+  try {
+    ingrData = await getIngredientInfo(
+      parsedIngr.ingredient || '',
+      spoonacularAPIKey
+    )
+  } catch (error: any) {
+    return {
+      error: { message: error.message },
+      ingredientData: null,
+      parsedIngredient: parsedIngr ?? null,
+    }
+  }
+  if (parsedIngr.ingredient && ingrData) {
+    const {
+      estimatedPrices,
+      meta,
+      categoryPath,
+      unit,
+      unitShort,
+      unitLong,
+      original,
+      id,
+      ...reducedIngrData
+    } = ingrData
+
+    const totalPrice = calculatePrice(
+      parsedIngr.quantity,
+      parsedIngr.unit,
+      estimatedPrices
+    )
+
+    const imagePath = `https://spoonacular.com/cdn/ingredients_100x100/${reducedIngrData.image}`
+    const updatedIngrData: IngredientData = {
+      ...reducedIngrData,
+      imagePath,
+      totalPriceUSACents: totalPrice,
+    }
+
+    return {
+      ingredientData: updatedIngrData,
+      parsedIngredient: parsedIngr,
+    }
+  } else {
+    return {
+      error: {
+        message:
+          'Ingredient not formatted correctly or Ingredient Unknown. Please pass ingredient comments/instructions after a comma',
+      },
+      ingredientData: null,
+      parsedIngredient: parsedIngr,
+    }
+  }
+}
+
+export default ingredientParser

package/src/funcs/parseIngredientString.ts

@@ -0,0 +1,77 @@
+import { ParsedIngredient } from '@jclind/ingredient-parser'
+import { parse } from 'recipe-ingredient-parser-v3'
+// import { ParsedIngredient } from '../../index.js'
+import { convertFractions } from './convertFractions.js'
+
+export const parseIngredientString = (ingrStr: string): ParsedIngredient => {
+  // Define regular expressions for text inside parentheses and text before the first comma
+  const parenRegex = /(\(.*?\))/
+  const commaRegex = /^(.*?)(?=,)/
+
+  // Extract the text inside the parentheses and the text before the first comma using regular expressions
+  const parenthesesStr = ingrStr.match(parenRegex)?.[1] ?? ''
+
+  const textWithoutParenthesesStr = ingrStr.replace(parenthesesStr, '')
+  // Find the index of the first ',' character
+  const commaIndex = textWithoutParenthesesStr.indexOf(',')
+
+  let ingrText: string
+  let comment: string
+
+  // If there is no comma in the string don't include a comment
+  if (commaIndex !== -1) {
+    ingrText = convertFractions(
+      textWithoutParenthesesStr
+        .substring(0, commaIndex)
+        .replace(parenRegex, '')
+        .trim()
+    )
+    comment = (
+      textWithoutParenthesesStr
+        .replace(parenRegex, '')
+        .substring(commaIndex + 1) +
+      ' ' +
+      parenthesesStr
+    ).trim()
+  } else {
+    ingrText = convertFractions(ingrStr.replace(parenRegex, '').trim())
+    comment = parenthesesStr.trim()
+  }
+
+  const prepIngrText = ingrText.replace(/\b(lb|lbs)\b/g, match => {
+    // Replace lb or lbs with pound or pounds respectively
+    if (match === 'lb') {
+      return 'pound'
+    } else {
+      return 'pounds'
+    }
+  })
+
+  const parsedIngrRes: Omit<
+    ParsedIngredient,
+    'originalIngredientString' | 'comment'
+  > = parse(prepIngrText, 'eng')
+
+  if (!parsedIngrRes.ingredient) {
+    return { ...parsedIngrRes, originalIngredientString: ingrStr, comment }
+  }
+
+  const wordsToRemove = ['small', 'medium', 'large', 'fresh', 'canned']
+  const regex = new RegExp('\\b(' + wordsToRemove.join('|') + ')\\b', 'gi')
+
+  const formattedIngrName = parsedIngrRes.ingredient
+    .trim()
+    .replace(/\s{2,}/g, ' ') // Replace multiple whitespace characters with a single space
+    .replace(/,/g, '') // Remove commas
+    .replace(/^(fluid|fl|oz) /, '') // Remove "fluid ", "fl ", or "oz " at the beginning of the string
+    .replace(regex, '')
+
+    .trim()
+
+  return {
+    ...parsedIngrRes,
+    ingredient: formattedIngrName,
+    originalIngredientString: ingrStr,
+    comment,
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './funcs/ingredientParser'
+export * from '@jclind/ingredient-parser'

package/tsconfig.json

@@ -0,0 +1,104 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ES6" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    "experimentalDecorators": true /* Enable experimental support for TC39 stage 2 draft decorators. */,
+    "emitDecoratorMetadata": true /* Emit design-type metadata for decorated declarations in source files. */,
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs" /* Specify what module code is generated. */,
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "NodeNext" /* Specify how TypeScript looks up a file from a given module specifier. */,
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "dist" /* Specify an output folder for all emitted files. */,
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    // "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+  },
+  "include": ["src/**/*", "types/**/*"],
+  "exclude": ["node_modules", "**/*.spec.ts"]
+}

package/types/index.d.ts

@@ -0,0 +1,83 @@
+declare module '@jclind/ingredient-parser' {
+  type StringOrNull = string | null
+  type NumberOrNull = number | null
+
+  export type IngredientResponse =
+    | {
+        parsedIngredient: ParsedIngredient
+        ingredientData: IngredientData
+        id?: string
+      }
+    | {
+        error: { message: string }
+        parsedIngredient: ParsedIngredient
+        ingredientData: IngredientData | null
+        id?: string
+      }
+
+  export type ParsedIngredient = {
+    quantity: NumberOrNull
+    unit: StringOrNull
+    unitPlural: StringOrNull
+    symbol: StringOrNull
+    ingredient: StringOrNull
+    originalIngredientString: string
+    minQty: NumberOrNull
+    maxQty: NumberOrNull
+    comment: StringOrNull
+  }
+
+  export interface IngredientData {
+    _id: string
+    ingredientId: number
+    originalName: string
+    name: string
+    amount: number
+    possibleUnits: string[]
+    consistency: string
+    shoppingListUnits: string[]
+    aisle: string
+    image: string
+    imagePath: string
+    nutrition: Nutrition
+    totalPriceUSACents: number
+  }
+
+  export interface Nutrition {
+    nutrients: Nutrient[]
+    properties: Property[]
+    flavonoids: Flavonoid[]
+    caloricBreakdown: CaloricBreakdown
+    weightPerServing: WeightPerServing
+  }
+
+  export interface Nutrient {
+    name: string
+    amount: number
+    unit: string
+    percentOfDailyNeeds: number
+  }
+
+  export interface Property {
+    name: string
+    amount: number
+    unit: string
+  }
+
+  export interface Flavonoid {
+    name: string
+    amount: number
+    unit: string
+  }
+
+  export interface CaloricBreakdown {
+    percentProtein: number
+    percentFat: number
+    percentCarbs: number
+  }
+
+  export interface WeightPerServing {
+    amount: number
+    unit: string
+  }
+}