@shopify/cli-hydrogen 5.4.2 → 5.5.0

package/dist/lib/transpile/morph/classes.js

@@ -0,0 +1,48 @@
+import { Node } from 'ts-morph';
+import { generateFunctionDocumentation } from './functions.js';
+import { getJsDocOrCreate } from './utils.js';
+
+function generateClassDocumentation(classNode) {
+  generateClassBaseDocumentation(classNode);
+  classNode.getMembers().forEach(generateClassMemberDocumentation);
+}
+function generateClassMemberDocumentation(classMember) {
+  generateModifierDocumentation(classMember);
+  if (Node.isPropertyDeclaration(classMember) || Node.isPropertyAssignment(classMember) || Node.isPropertySignature(classMember)) {
+    generateClassPropertyDocumentation(classMember);
+  }
+  if (Node.isMethodDeclaration(classMember) || Node.isConstructorDeclaration(classMember)) {
+    generateFunctionDocumentation(classMember);
+  }
+}
+function generateClassBaseDocumentation(classNode) {
+  const jsDoc = getJsDocOrCreate(classNode);
+  const extendedClass = classNode.getExtends();
+  if (extendedClass) {
+    jsDoc.addTag({ tagName: "extends", text: extendedClass.getText() });
+  }
+}
+function generateClassPropertyDocumentation(classMember) {
+  const structure = classMember.getStructure();
+  if (structure && "initializer" in structure) {
+    const initializer = structure.initializer;
+    if (initializer && initializer !== "undefined") {
+      const jsDoc = getJsDocOrCreate(classMember);
+      jsDoc.addTag({ tagName: "default", text: initializer });
+    }
+  }
+}
+function generateModifierDocumentation(classMember) {
+  if ("getModifiers" in classMember) {
+    const modifiers = classMember.getModifiers() || [];
+    for (const modifier of modifiers) {
+      const text = modifier?.getText();
+      if (["public", "private", "protected", "readonly", "static"].includes(text)) {
+        const jsDoc = getJsDocOrCreate(classMember);
+        jsDoc.addTag({ tagName: text });
+      }
+    }
+  }
+}
+
+export { generateClassDocumentation };

package/dist/lib/transpile/morph/functions.js

@@ -0,0 +1,76 @@
+import { getJsDocOrCreate, sanitizeType } from './utils.js';
+
+function generateFunctionDocumentation(functionNode, variableStatement) {
+  const outputDocNode = getOutputJsDocNodeOrCreate(
+    functionNode,
+    variableStatement
+  );
+  generateParameterDocumentation(functionNode, outputDocNode);
+  const jsDocs = variableStatement?.getJsDocs()[0];
+  if (jsDocs?.getTags().length === 0) {
+    const declaration = variableStatement?.getDeclarations()[0];
+    const type = declaration?.getType().getText();
+    if (type && type !== "any" && type !== "unknown") {
+      const tagName = type.startsWith("() =>") ? "return" : "type";
+      const normalizedType = type.replace(/^\(\)\s+=>\s+/, "").replace(/typeof import\("[^"]+"\)\./, "typeof ");
+      const text = normalizedType === "SerializeFrom<typeof loader>" ? `{LoaderReturnData}` : `{${normalizedType}}`;
+      jsDocs.addTag({ tagName, text });
+    }
+  }
+}
+function generateParameterDocumentation(functionNode, docNode) {
+  const params = functionNode.getParameters();
+  const jsDoc = getJsDocOrCreate(docNode);
+  const paramTags = (jsDoc.getTags() || []).filter(
+    (tag) => ["param", "parameter"].includes(tag.getTagName())
+  );
+  const commentLookup = Object.fromEntries(
+    paramTags.map((tag) => [
+      // @ts-ignore
+      tag.compilerNode.name?.getText().replace(/\[|\]|(=.*)/g, "").trim(),
+      (tag.getComment() || "").toString().trim()
+    ])
+  );
+  const preferredTagName = paramTags[0]?.getTagName();
+  paramTags.forEach((tag) => tag.remove());
+  for (const param of params) {
+    const paramType = sanitizeType(param.getTypeNode()?.getText());
+    if (!paramType)
+      continue;
+    const paramName = param.compilerNode.name?.getText();
+    const isOptional = param.isOptional();
+    const isRest = param.isRestParameter();
+    const paramTypeOut = isRest ? `...${paramType.replace(/\[\]\s*$/, "")}` : paramType;
+    let defaultValue;
+    if (isOptional) {
+      const paramInitializer = param.getInitializer();
+      defaultValue = paramInitializer?.getText().replaceAll(/(\s|\t)*\n(\s|\t)*/g, " ");
+    }
+    let paramNameOut = paramName;
+    if (paramNameOut.match(/[{},]/))
+      paramNameOut = "";
+    if (paramNameOut && isOptional) {
+      const defaultValueOut = defaultValue !== void 0 ? `=${defaultValue}` : "";
+      paramNameOut = `[${paramNameOut}${defaultValueOut}]`;
+    }
+    paramNameOut = paramNameOut ? ` ${paramNameOut}` : "";
+    const comment = commentLookup[paramName.trim()];
+    jsDoc.addTag({
+      tagName: preferredTagName || "param",
+      text: `{${paramTypeOut}}${paramNameOut}${comment ? ` ${comment}` : ""}`
+    });
+  }
+}
+function getOutputJsDocNodeOrCreate(functionNode, docNode) {
+  if (docNode) {
+    const funcNodeDocs = functionNode.getJsDocs();
+    if (funcNodeDocs.length)
+      return functionNode;
+    getJsDocOrCreate(docNode);
+    return docNode;
+  }
+  getJsDocOrCreate(functionNode);
+  return functionNode;
+}
+
+export { generateFunctionDocumentation };

package/dist/lib/transpile/morph/index.js

@@ -0,0 +1,67 @@
+import { ScriptTarget, ts, Project, SyntaxKind, Node } from 'ts-morph';
+import { generateClassDocumentation } from './classes.js';
+import { generateFunctionDocumentation } from './functions.js';
+import { generateTypeDefs } from './typedefs.js';
+
+const DEFAULT_COMPILER_OPTIONS = {
+  target: ScriptTarget.ESNext,
+  esModuleInterop: true,
+  jsx: ts.JsxEmit.Preserve,
+  removeComments: false,
+  lib: ["DOM", "DOM.Iterable", "ES2022"]
+};
+function transpileTs(src, filepath, addJsDoc) {
+  return addJsDoc ? transpileTsWithJSDocs(src, filepath, DEFAULT_COMPILER_OPTIONS) : restoreCode(
+    ts.transpileModule(escapeCode(src), {
+      reportDiagnostics: false,
+      compilerOptions: DEFAULT_COMPILER_OPTIONS
+    }).outputText
+  );
+}
+const BLANK_LINE_MARKER = "// BLANK_LINE_MARKER //";
+const COMMENT_PROTECTOR_HEADER = "const __COMMENT_PROTECTOR_HEADER = 1;\n";
+function escapeCode(code) {
+  code = COMMENT_PROTECTOR_HEADER + code;
+  return code.split("\n").map((line) => line.match(/^[\s\t]*$/) ? BLANK_LINE_MARKER + line : line).join("\n");
+}
+function restoreCode(code) {
+  return code.replace(COMMENT_PROTECTOR_HEADER, "").split("\n").map((rawLine) => {
+    const line = rawLine.trim();
+    return line.startsWith(BLANK_LINE_MARKER) ? line.slice(BLANK_LINE_MARKER.length) : rawLine;
+  }).join("\n").trim();
+}
+function transpileTsWithJSDocs(src, filepath, compilerOptions = {}) {
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: false,
+    compilerOptions
+  });
+  const sourceFile = project.createSourceFile(filepath, escapeCode(src));
+  sourceFile.getClasses().forEach(generateClassDocumentation);
+  sourceFile.getFunctions().forEach((node) => generateFunctionDocumentation(node));
+  sourceFile.getVariableDeclarations().forEach((varDeclaration) => {
+    const initializer = varDeclaration.getInitializerIfKind(SyntaxKind.ArrowFunction) || varDeclaration.getInitializerIfKind(SyntaxKind.FunctionExpression);
+    if (!initializer)
+      return void 0;
+    generateFunctionDocumentation(
+      initializer,
+      varDeclaration.getVariableStatement()
+    );
+  });
+  sourceFile.getDefaultExportSymbol()?.getValueDeclaration()?.getChildren()?.find(Node.isObjectLiteralExpression)?.forEachChild((child) => {
+    if (Node.isFunctionLikeDeclaration(child)) {
+      generateFunctionDocumentation(child);
+    }
+  });
+  let result = project.emitToMemory()?.getFiles()?.find(
+    (file) => file.filePath.slice(0, -3) === sourceFile.getFilePath().slice(0, -3)
+  )?.text;
+  if (!result)
+    throw new Error("Could not emit output to memory.");
+  result = restoreCode(result);
+  result = generateTypeDefs(sourceFile, result);
+  return result.replace(/^\s*\/\*[*\s]+\*\/$\n/gm, "\n").trim() + "\n";
+}
+
+export { DEFAULT_COMPILER_OPTIONS, transpileTs };

package/dist/lib/transpile/morph/typedefs.js

@@ -0,0 +1,133 @@
+import { getJsDocOrCreate, sanitizeType } from './utils.js';
+
+function generateTypeDefs(sourceFile, code) {
+  const typedefs = sourceFile.getTypeAliases().map(
+    (typeAlias) => generateTypedefDocumentation(typeAlias, sourceFile).trim()
+  ).concat(
+    sourceFile.getInterfaces().map(
+      (interfaceNode) => generateInterfaceDocumentation(interfaceNode).trim()
+    )
+  );
+  const typeImports = sourceFile.getImportDeclarations().filter((imp) => /({|\s|\n)type\s/.test(imp.getText()));
+  const typedefsFromImports = /* @__PURE__ */ new Map();
+  for (const typeImport of typeImports) {
+    const typeElements = [];
+    const isFullType = typeImport.isTypeOnly();
+    for (const namedImport of typeImport.getNamedImports()) {
+      if (isFullType || namedImport.isTypeOnly()) {
+        typeElements.push(namedImport.getName());
+      }
+    }
+    if (typeElements.length > 0) {
+      typedefsFromImports.set(
+        typeImport.getModuleSpecifierValue(),
+        typeElements
+      );
+    }
+  }
+  typedefs.push("");
+  typedefsFromImports.forEach((typeElements, moduleSpecifier) => {
+    for (const typeElement of typeElements) {
+      if (typeElement === "SerializeFrom")
+        continue;
+      const hasGeneric = typeElement === "V2_MetaFunction";
+      typedefs.push(
+        `/** ${hasGeneric ? "@template T " : ""}@typedef {import('${moduleSpecifier}').${typeElement}${hasGeneric ? "<T>" : ""}} ${typeElement} */`
+      );
+    }
+  });
+  const filepath = sourceFile.getFilePath();
+  if (filepath.includes("routes") || filepath.includes("root.")) {
+    const source = sourceFile.getText();
+    if (/(function loader\(|const loader =)/.test(source)) {
+      typedefs.push(
+        `/** @typedef {import('@shopify/remix-oxygen').SerializeFrom<typeof loader>} LoaderReturnData */`
+      );
+      code = code.replace(
+        /^\s+?const\s+([\w\d]+|\{[\w\d\s,.]+\})\s+?=\s+?useLoaderData\(\)/gms,
+        "/** @type {LoaderReturnData} */\n$&"
+      );
+    }
+    if (/(function action\(|const action =)/.test(source)) {
+      typedefs.push(
+        `/** @typedef {import('@shopify/remix-oxygen').SerializeFrom<typeof action>} ActionReturnData */`
+      );
+      code = code.replace(
+        /^\s+?const\s+([\w\d]+|\{[\w\d\s,.]+\})\s+?=\s+?useActionData\(\)/gms,
+        "/** @type {ActionReturnData} */\n$&"
+      );
+    }
+  }
+  return code + `
+
+${typedefs.join("\n")}
+`;
+}
+function generateInterfaceDocumentation(interfaceNode) {
+  const name = interfaceNode.getName();
+  const jsDoc = getJsDocOrCreate(interfaceNode);
+  jsDoc.addTag({ tagName: "typedef", text: `{Object} ${name}` });
+  interfaceNode.getProperties().forEach((prop) => {
+    generateObjectPropertyDocumentation(prop, jsDoc);
+  });
+  return jsDoc.getFullText();
+}
+function generateTypedefDocumentation(typeNode, sourceFile) {
+  const name = typeNode.getName();
+  let { type } = typeNode.getStructure();
+  if (typeof type !== "string")
+    return "";
+  type = sanitizeType(type);
+  const dummyNode = sourceFile.addVariableStatement({
+    declarations: [{ name: `__dummy${name}`, initializer: "null" }]
+  });
+  const typeParams = typeNode.getTypeParameters();
+  const jsDoc = dummyNode.addJsDoc({
+    tags: [
+      {
+        tagName: "typedef",
+        text: `{${type}} ${name}`
+      },
+      ...typeParams.map((param) => {
+        const constraint = param.getConstraint();
+        const defaultType = param.getDefault();
+        const paramName = param.getName();
+        const nameWithDefault = defaultType ? `[${paramName}=${defaultType.getText()}]` : paramName;
+        return {
+          tagName: "template",
+          text: `${constraint ? `{${constraint.getText()}} ` : ""}${nameWithDefault}`
+        };
+      })
+    ]
+  }).getText();
+  dummyNode.remove();
+  return jsDoc;
+}
+function getChildProperties(node) {
+  const properties = node.getType().getProperties();
+  const valueDeclarations = properties.map((child) => child.getValueDeclaration()).filter((child) => node.getFullText().includes(child?.getFullText()));
+  return valueDeclarations ?? [];
+}
+function generateObjectPropertyDocumentation(node, jsDoc, name = "", topLevelCall = true) {
+  name = name || node.getName();
+  if (!topLevelCall)
+    name = `${name}.${node.getName()}`;
+  let propType = node.getTypeNode()?.getText()?.replace(/\n/g, "")?.replace(/\s/g, "");
+  propType = sanitizeType(propType);
+  const isOptional = node.hasQuestionToken() || node.getJsDocs()?.[0]?.getTags()?.some((tag) => tag.getTagName() === "optional");
+  const existingPropDocs = node.getJsDocs()?.[0]?.getDescription() || "";
+  const children = getChildProperties(node);
+  if (children.length)
+    propType = "Object";
+  jsDoc.addTag({
+    tagName: "property",
+    text: `{${propType}} ${isOptional ? `[${name}]` : name} ${existingPropDocs}`
+  });
+  if (children.length) {
+    children.forEach(
+      (child) => generateObjectPropertyDocumentation(child, jsDoc, name, false)
+    );
+  }
+}
+
+export { generateTypeDefs };

package/dist/lib/transpile/morph/utils.js

@@ -0,0 +1,15 @@
+function getJsDocOrCreate(node) {
+  return node.getJsDocs().at(-1) || node.addJsDoc({ description: "\n" });
+}
+function sanitizeType(str) {
+  if (!str)
+    return str;
+  const extractedClassFromTypeof = /{*typeof\s+([^(?:}|\s);]*)/gm.exec(
+    str
+  )?.[1];
+  if (!extractedClassFromTypeof)
+    return str;
+  return `Class<${extractedClassFromTypeof}>`;
+}
+
+export { getJsDocOrCreate, sanitizeType };

package/dist/lib/{transpile-ts.js → transpile/project.js}

@@ -1,48 +1,20 @@
 import { glob, removeFile, readFile, writeFile } from '@shopify/cli-kit/node/fs';
 import { outputDebug } from '@shopify/cli-kit/node/output';
 import { joinPath } from '@shopify/cli-kit/node/path';
-import { getCodeFormatOptions, formatCode } from './format-code.js';
+import { getCodeFormatOptions, formatCode } from '../format-code.js';
+import { transpileFile } from './file.js';
 
-const escapeNewLines = (code) => code.replace(/\n\n/g, "\n/* :newline: */");
-const restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
-const DEFAULT_TS_CONFIG = {
-  lib: ["DOM", "DOM.Iterable", "ES2022"],
-  isolatedModules: true,
-  esModuleInterop: true,
-  resolveJsonModule: true,
-  target: "ES2022",
-  strict: true,
-  allowJs: true,
-  forceConsistentCasingInFileNames: true,
-  skipLibCheck: true
-};
-async function transpileFile(code, config = DEFAULT_TS_CONFIG) {
-  const tsImport = await import('typescript');
-  const ts = tsImport.default ?? tsImport;
-  const withArtificialNewLines = escapeNewLines(code);
-  const compiled = ts.transpileModule(withArtificialNewLines, {
-    reportDiagnostics: false,
-    compilerOptions: {
-      ...config,
-      // '1' tells TypeScript to preserve the JSX syntax.
-      jsx: 1,
-      removeComments: false
-    }
-  });
-  return restoreNewLines(compiled.outputText);
-}
 const DEFAULT_JS_CONFIG = {
-  allowJs: true,
-  forceConsistentCasingInFileNames: true,
-  strict: true,
-  lib: ["DOM", "DOM.Iterable", "ES2022"],
-  esModuleInterop: true,
-  isolatedModules: true,
-  jsx: "react-jsx",
-  noEmit: true,
-  resolveJsonModule: true
+  checkJs: false,
+  target: "ES2022",
+  module: "ES2022",
+  moduleResolution: "bundler",
+  baseUrl: ".",
+  paths: {
+    "~/*": ["app/*"]
+  }
 };
-const JS_CONFIG_KEYS = [
+const JS_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "noLib",
   "target",
   "module",
@@ -53,13 +25,13 @@ const JS_CONFIG_KEYS = [
   "baseUrl",
   "paths",
   ...Object.keys(DEFAULT_JS_CONFIG)
-];
-function convertConfigToJS(tsConfig) {
+]);
+function convertConfigToJS(tsConfig, keepTypes = false) {
   const jsConfig = {
     compilerOptions: { ...DEFAULT_JS_CONFIG }
   };
   if (tsConfig.include) {
-    jsConfig.include = tsConfig.include.filter((s) => !s.endsWith(".d.ts")).map((s) => s.replace(/\.ts(x?)$/, ".js$1"));
+    jsConfig.include = tsConfig.include.filter((s) => keepTypes || !s.endsWith(".d.ts")).map((s) => s.replace(/(?<!\.d)\.ts(x?)$/, ".js$1"));
   }
   if (tsConfig.compilerOptions) {
     for (const key of JS_CONFIG_KEYS) {
@@ -70,7 +42,7 @@ function convertConfigToJS(tsConfig) {
   }
   return jsConfig;
 }
-async function transpileProject(projectDir) {
+async function transpileProject(projectDir, keepTypes = true) {
   const entries = await glob("**/*.+(ts|tsx)", {
     absolute: true,
     cwd: projectDir
@@ -78,11 +50,15 @@ async function transpileProject(projectDir) {
   const formatConfig = await getCodeFormatOptions();
   for (const entry of entries) {
     if (entry.endsWith(".d.ts")) {
-      await removeFile(entry);
+      if (!keepTypes)
+        await removeFile(entry);
       continue;
     }
     const tsx = await readFile(entry);
-    const mjs = await formatCode(await transpileFile(tsx), formatConfig);
+    const mjs = await formatCode(
+      await transpileFile(tsx, entry, keepTypes),
+      formatConfig
+    );
     await removeFile(entry);
     await writeFile(entry.replace(/\.ts(x?)$/, ".js$1"), mjs);
   }
@@ -100,7 +76,8 @@ async function transpileProject(projectDir) {
     const tsConfigPath = joinPath(projectDir, "tsconfig.json");
     const tsConfigWithComments = await readFile(tsConfigPath);
     const jsConfig = convertConfigToJS(
-      JSON.parse(tsConfigWithComments.replace(/^\s*\/\/.*$/gm, ""))
+      JSON.parse(tsConfigWithComments.replace(/^\s*\/\/.*$/gm, "")),
+      keepTypes
     );
     await removeFile(tsConfigPath);
     await writeFile(
@@ -117,19 +94,21 @@ async function transpileProject(projectDir) {
       await readFile(joinPath(projectDir, "package.json"))
     );
     delete pkgJson.scripts["typecheck"];
-    delete pkgJson.devDependencies["typescript"];
-    delete pkgJson.devDependencies["@shopify/oxygen-workers-types"];
-    for (const key of Object.keys(pkgJson.devDependencies)) {
-      if (key.startsWith("@types/")) {
-        delete pkgJson.devDependencies[key];
+    if (!keepTypes) {
+      delete pkgJson.devDependencies["typescript"];
+      delete pkgJson.devDependencies["@shopify/oxygen-workers-types"];
+      for (const key of Object.keys(pkgJson.devDependencies)) {
+        if (key.startsWith("@types/")) {
+          delete pkgJson.devDependencies[key];
+        }
+      }
+      const codegenFlag = /\s*--codegen(-unstable)?/;
+      if (pkgJson.scripts?.dev) {
+        pkgJson.scripts.dev = pkgJson.scripts.dev.replace(codegenFlag, "");
+      }
+      if (pkgJson.scripts?.build) {
+        pkgJson.scripts.build = pkgJson.scripts.build.replace(codegenFlag, "");
       }
-    }
-    const codegenFlag = /\s*--codegen(-unstable)?/;
-    if (pkgJson.scripts?.dev) {
-      pkgJson.scripts.dev = pkgJson.scripts.dev.replace(codegenFlag, "");
-    }
-    if (pkgJson.scripts?.build) {
-      pkgJson.scripts.build = pkgJson.scripts.build.replace(codegenFlag, "");
     }
     await writeFile(
       joinPath(projectDir, "package.json"),
@@ -152,4 +131,4 @@ async function transpileProject(projectDir) {
   }
 }
 
-export { convertConfigToJS, transpileFile, transpileProject };
+export { transpileProject };

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.4.2",
+  "version": "5.5.0",
   "commands": {
     "hydrogen:build": {
       "id": "hydrogen:build",
@@ -592,6 +592,32 @@
       },
       "args": {}
     },
+    "hydrogen:debug:cpu": {
+      "id": "hydrogen:debug:cpu",
+      "description": "Builds and profiles the server startup time the app.",
+      "strict": true,
+      "pluginName": "@shopify/cli-hydrogen",
+      "pluginAlias": "@shopify/cli-hydrogen",
+      "pluginType": "core",
+      "aliases": [],
+      "flags": {
+        "path": {
+          "name": "path",
+          "type": "option",
+          "description": "The path to the directory of the Hydrogen storefront. The default is the current directory.",
+          "multiple": false
+        },
+        "output": {
+          "name": "output",
+          "type": "option",
+          "description": "Specify a path to generate the profile file. Defaults to \"startup.cpuprofile\".",
+          "required": false,
+          "multiple": false,
+          "default": "startup.cpuprofile"
+        }
+      },
+      "args": {}
+    },
     "hydrogen:env:list": {
       "id": "hydrogen:env:list",
       "description": "List the environments on your linked Hydrogen storefront.",

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "@shopify:registry": "https://registry.npmjs.org"
   },
-  "version": "5.4.2",
+  "version": "5.5.0",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -12,8 +12,8 @@
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
     "generate:manifest": "node scripts/generate-manifest.mjs",
-    "test": "cross-env SHOPIFY_UNIT_TEST=1 vitest run --test-timeout=15000",
-    "test:watch": "cross-env SHOPIFY_UNIT_TEST=1 vitest --test-timeout=15000"
+    "test": "cross-env SHOPIFY_UNIT_TEST=1 vitest run --test-timeout=20000",
+    "test:watch": "cross-env SHOPIFY_UNIT_TEST=1 vitest --test-timeout=20000"
   },
   "devDependencies": {
     "@types/diff": "^5.0.2",
@@ -37,7 +37,7 @@
     "@oclif/core": "2.11.7",
     "@shopify/cli-kit": "3.49.2",
     "@shopify/hydrogen-codegen": "^0.0.2",
-    "@shopify/mini-oxygen": "^2.2.1",
+    "@shopify/mini-oxygen": "^2.2.3",
     "@shopify/oxygen-cli": "^2.0.0",
     "ansi-escapes": "^6.2.0",
     "diff": "^5.1.0",
@@ -49,15 +49,15 @@
     "source-map": "^0.7.4",
     "stack-trace": "^1.0.0-pre2",
     "tar-fs": "^2.1.1",
-    "typescript": "^5.2.2",
+    "ts-morph": "20.0.0",
     "use-resize-observer": "^9.1.0",
     "ws": "^8.13.0"
   },
   "peerDependencies": {
     "@remix-run/dev": "1.19.1",
     "@remix-run/react": "1.19.1",
-    "@shopify/hydrogen-react": "^2023.7.4",
-    "@shopify/remix-oxygen": "^1.1.6"
+    "@shopify/hydrogen-react": "^2023.7.5",
+    "@shopify/remix-oxygen": "^1.1.8"
   },
   "peerDependenciesMeta": {
     "@remix-run/dev": {