Merge pull request #344 from marko-js/ignore-non-marko-missing-types

fix: ignore tag types for non-marko templates

Author: rturnq

.changeset/happy-glasses-trade.md

@@ -0,0 +1,8 @@
+---
+"@marko/language-server": patch
+"@marko/language-tools": patch
+"@marko/type-check": patch
+"marko-vscode": patch
+---
+
+Ignore types for non-Marko templates to remove errors for missing types

packages/language-server/src/__tests__/fixtures/script/import-without-types/__snapshots__/import-without-types.expected/index.html

@@ -0,0 +1,53 @@
+export interface Input {}
+abstract class Component extends Marko.Component<Input> {}
+export { type Component };
+(function (this: void) {
+  const input = Marko._.any as Input;
+  const component = Marko._.any as Component;
+  const state = Marko._.state(component);
+  const out = Marko._.out;
+  const $signal = Marko._.any as AbortSignal;
+  const $global = Marko._.getGlobal(
+    // @ts-expect-error We expect the compiler to error because we are checking if the MarkoRun.Context is defined.
+    (Marko._.error, Marko._.any as MarkoRun.Context),
+  );
+  Marko._.noop({ component, state, out, input, $global, $signal });
+  const Child = null;
+  const __marko_internal_tag_1 = Marko._.fallbackTemplate(Child, Marko._.any);
+  Marko._.renderDynamicTag(__marko_internal_tag_1)()()({
+    a: 1,
+  });
+  Marko._.renderDynamicTag(Marko._.missingTag)()()({
+    a: 1,
+  });
+  return;
+})();
+export default new (class Template extends Marko._.Template<{
+  render(
+    input: Marko.TemplateInput<Input>,
+    stream?: {
+      write: (chunk: string) => void;
+      end: (chunk?: string) => void;
+    },
+  ): Marko.Out<Component>;
+
+  render(
+    input: Marko.TemplateInput<Input>,
+    cb?: (err: Error | null, result: Marko.RenderResult<Component>) => void,
+  ): Marko.Out<Component>;
+
+  renderSync(input: Marko.TemplateInput<Input>): Marko.RenderResult<Component>;
+
+  renderToString(input: Marko.TemplateInput<Input>): string;
+
+  stream(
+    input: Marko.TemplateInput<Input>,
+  ): ReadableStream<string> & NodeJS.ReadableStream;
+
+  api: "class";
+  _(): () => <__marko_internal_input extends unknown>(
+    input: Marko.Directives &
+      Input &
+      Marko._.Relate<__marko_internal_input, Marko.Directives & Input>,
+  ) => Marko._.ReturnWithScope<__marko_internal_input, void>;
+}> {})();

packages/language-server/src/__tests__/fixtures/script/import-without-types/__snapshots__/import-without-types.expected/index.md

@@ -0,0 +1,3 @@
+{
+  "renderer": "./index.js"
+}

packages/language-server/src/__tests__/fixtures/script/import-without-types/__snapshots__/import-without-types.expected/index.ts

@@ -0,0 +1,3 @@
+{
+  "renderer": "./index.js"
+}

packages/language-server/src/__tests__/fixtures/script/import-without-types/components/Child/index.js

@@ -718,34 +718,42 @@ constructor(_?: Return) {}
     const renderId = this.#getRenderId(tag);
     const def = tagName ? this.#lookup.getTag(tagName) : undefined;
     const isHTML = def?.html;
-    const importPath = !isHTML && resolveTagImport(this.#filename, def);
+    const importPath = !isHTML
+      ? resolveTagImport(this.#filename, def)
+      : undefined;
     let tagIdentifier: undefined | string;
     let isTemplate = false;
 
     if (!isHTML && (!def || importPath)) {
-      const tagId = this.#ensureTagId(tag);
-      tagIdentifier = varLocal("tag_" + tagId);
-      this.#extractor.write(`const ${tagIdentifier} = (\n`);
+      const isIdentifier = tagName && REG_TAG_NAME_IDENTIFIER.test(tagName);
+      const isMarkoFile = importPath?.endsWith(".marko");
 
-      if (tagName && REG_TAG_NAME_IDENTIFIER.test(tagName)) {
-        if (importPath) {
+      if (isIdentifier || isMarkoFile || !importPath) {
+        tagIdentifier = varLocal("tag_" + this.#ensureTagId(tag));
+        this.#extractor.write(`const ${tagIdentifier} = (\n`);
+
+        if (isIdentifier) {
+          if (importPath) {
+            this.#extractor.write(
+              `${varShared("fallbackTemplate")}(${tagName},${isMarkoFile ? `import("${importPath}")` : varShared("any")})`,
+            );
+          } else {
+            this.#extractor.copy(tag.name);
+          }
+        } else if (isMarkoFile) {
+          isTemplate = true;
           this.#extractor.write(
-            `${varShared("fallbackTemplate")}(${tagName},import("${importPath}"))`,
+            `${varShared("resolveTemplate")}(import("${importPath}"))`,
           );
         } else {
-          this.#extractor.copy(tag.name);
+          this.#writeDynamicTagName(tag);
         }
-      } else if (importPath) {
-        isTemplate = importPath.endsWith(".marko");
-        this.#extractor.write(
-          `${varShared("resolveTemplate")}(import("${importPath}"))`,
-        );
+
+        this.#extractor.write("\n);\n");
       } else {
-        this.#writeDynamicTagName(tag);
+        tagIdentifier = varShared("missingTag");
       }
 
-      this.#extractor.write("\n);\n");
-
       const attrTagTree = this.#getAttrTagTree(tag);
       if (attrTagTree) {
         this.#writeAttrTagTree(attrTagTree, tagIdentifier);