@mbler/mcx-core 0.0.7-alpha.r1 → 0.0.7-alpha.r3

package/dist/index.d.ts

@@ -352,7 +352,7 @@ interface ItemComponentOpt {
     id: string;
     name: string;
     format: string;
-    components: {
+    components: Partial<{
         offHand: boolean;
         damage: number;
         DestroyInCreate: boolean;
@@ -1147,7 +1147,7 @@ interface ItemComponentOpt {
              */
             value?: number;
         };
-    };
+    }>;
 }
 type JSONValue<T> = T | {
     value: T;

package/dist/index.js

@@ -1822,6 +1822,24 @@ async function Comp$1(ctx) {
 }
 
 async function Comp(ctx) {
+    const resolveImportCandidates = (importerId, source) => {
+        const baseDir = path.dirname(importerId);
+        const sourcePath = path.resolve(baseDir, source);
+        const parsed = path.parse(sourcePath);
+        const mcxExt = ".mcx";
+        const candidates = new Set();
+        // compileMCXFn only accepts mcx source; normalize all import styles to .mcx candidates.
+        if (parsed.ext === mcxExt) {
+            candidates.add(sourcePath);
+        }
+        else {
+            // e.g. ./foo or ./foo.js -> ./foo.mcx
+            candidates.add(path.join(parsed.dir, `${parsed.name}${mcxExt}`));
+        }
+        // e.g. ./foo -> ./foo/index.mcx
+        candidates.add(path.join(sourcePath, `index${mcxExt}`));
+        return [...candidates];
+    };
     const eventImportIdList = [];
     for (const impNode of ctx.ctx.compiledCode.JSIR.BuildCache.import) {
         const source = impNode.source;
@@ -1829,34 +1847,45 @@ async function Comp(ctx) {
         if (!parsed.root && !parsed.dir.startsWith(".")) {
             continue;
         }
-        // path
-        const fPath = path.join(ctx.ctx.currentId, "../", source);
-        try {
-            // read file
-            const code = await fs.readFile(fPath, "utf-8");
-            const compiledCode = compileMCXFn(code);
-            // write cache
-            ctx.ctx.cache.set(fPath, compiledCode);
-            if (compiledCode.strLoc.Event.isLoad) {
-                for (const impItem of impNode.imported) {
-                    let type;
-                    if (impItem.isAll)
-                        type = "all";
-                    else if (impItem.import == "default")
-                        type = "default";
-                    else {
-                        throw new Error("not vaild importDeclartion: Event mcx only resolve default and all import, can't use other import");
-                    }
-                    eventImportIdList.push({
-                        type,
-                        as: impItem.as
-                    });
+        const candidates = resolveImportCandidates(ctx.ctx.currentId, source);
+        let resolvedPath = null;
+        let compileResult = null;
+        let lastErr = null;
+        for (const candidate of candidates) {
+            try {
+                const code = await fs.readFile(candidate, "utf-8");
+                compileResult = compileMCXFn(code);
+                resolvedPath = candidate;
+                break;
+            }
+            catch (err) {
+                if (err?.code === "ENOENT") {
+                    continue;
                 }
+                lastErr = err;
+                break;
             }
         }
-        catch (err) {
-            // if error: file not found, file can't write, mcx syntax error
-            ctx.ctx.rollupContext.warn(`[extract import]: can't resolve file ${fPath} and import by ${ctx.ctx.currentId}\n- err: ${(err instanceof Error) ? err.stack : err}`);
+        if (!resolvedPath || !compileResult) {
+            ctx.ctx.rollupContext.warn(`[extract import]: can't resolve file from ${source} by ${ctx.ctx.currentId}\n- candidates: ${candidates.join(", ")}\n- err: ${(lastErr instanceof Error) ? lastErr.stack : lastErr ?? "not found"}`);
+            continue;
+        }
+        ctx.ctx.cache.set(resolvedPath, compileResult);
+        if (compileResult.strLoc.Event.isLoad) {
+            for (const impItem of impNode.imported) {
+                let type;
+                if (impItem.isAll)
+                    type = "all";
+                else if (impItem.import == "default")
+                    type = "default";
+                else {
+                    throw new Error("not vaild importDeclartion: Event mcx only resolve default and all import, can't use other import");
+                }
+                eventImportIdList.push({
+                    type,
+                    as: impItem.as
+                });
+            }
         }
     }
     // only have event import