@vuebro/loader-sfc 2.3.14 → 2.3.16

package/dist/loader-sfc.js

@@ -1,19 +1,11 @@
-import { compileStyleAsync, compileTemplate, compileScript, parse, } from "vue/compiler-sfc";
 import { consola } from "consola/browser";
-import { transform } from "sucrase";
 import hash from "hash-sum";
-const fetching = async (input, resolver = "text") => {
+import { ofetch } from "ofetch";
+import { transform } from "sucrase";
+import { compileScript, compileStyleAsync, compileTemplate, parse, } from "vue/compiler-sfc";
+const fetching = async (input) => {
     try {
-        const response = await fetch(input);
-        if (response.ok) {
-            const method = response[resolver];
-            if (typeof method === "function")
-                return await method();
-            else
-                throw new Error(`Invalid resolver "${resolver}"`);
-        }
-        else
-            throw new Error(`Response status: ${response.status.toString()}`);
+        return await ofetch(input);
     }
     catch (error) {
         consola.error(error);
@@ -27,32 +19,32 @@ const fetching = async (input, resolver = "text") => {
         URL.revokeObjectURL(objectURL);
     }
 };
-export default async (filename, { scriptOptions: { templateOptions: { compilerOptions: { expressionPlugins, ...restCompilerOptions } = {}, ...restTemplateOptions } = {}, ...restScriptOptions } = {}, parseOptions, styleOptions, } = {}) => {
+export default async (filename, { parseOptions, scriptOptions: { templateOptions: { compilerOptions: { expressionPlugins, ...restCompilerOptions } = {}, ...restTemplateOptions } = {}, ...restScriptOptions } = {}, styleOptions, } = {}) => {
     const id = `data-v-${hash(filename)}`;
-    const { errors: parseErrors, descriptor } = parse((await fetching(filename)) ?? "<template></template>", { filename, ...parseOptions });
-    const { scriptSetup, template, slotted, script, styles } = descriptor;
+    const { descriptor, errors: parseErrors } = parse((await fetching(filename)) ?? "<template></template>", { filename, ...parseOptions });
+    const { script, scriptSetup, slotted, styles, template } = descriptor;
     const langs = new Set([script, scriptSetup]
         .filter((scriptBlock) => scriptBlock !== null)
         .flatMap(({ lang = "js" }) => [
         ...(/[jt]sx$/.test(lang) ? ["jsx"] : []),
         ...(/tsx?$/.test(lang) ? ["typescript"] : []),
-    ])), { content: source = "", ast } = template ?? {};
+    ])), { ast, content: source = "" } = template ?? {};
     let styleWarning = "";
     const styleErrors = [];
     const style = !(document.getElementById(id) instanceof HTMLStyleElement)
-        ? Promise.all(styles.map(async ({ scoped = false, content, module, src }) => {
+        ? Promise.all(styles.map(async ({ content, module, scoped = false, src }) => {
             const modules = !!module;
             if (modules && !styleWarning) {
                 styleWarning = "<style module> is not supported in the playground.";
                 return "";
             }
             else {
-                const { errors, code } = await compileStyleAsync({
-                    source: src ? ((await fetching(src)) ?? "") : content,
+                const { code, errors } = await compileStyleAsync({
                     filename,
+                    id,
                     modules,
                     scoped,
-                    id,
+                    source: src ? ((await fetching(src)) ?? "") : content,
                     ...styleOptions,
                 });
                 styleErrors.push(...errors);
@@ -64,34 +56,34 @@ export default async (filename, { scriptOptions: { templateOptions: { compilerOp
         expressionPlugins: [
             ...new Set([...(expressionPlugins ?? []), ...langs]),
         ],
-        scopeId: id,
         filename,
+        scopeId: id,
         slotted,
         ...restCompilerOptions,
     }, templateOptions = {
-        scoped: styles.some(({ scoped }) => scoped),
         compilerOptions,
         filename,
-        slotted,
         id,
+        scoped: styles.some(({ scoped }) => scoped),
+        slotted,
         ...restTemplateOptions,
     }, scriptOptions = {
-        templateOptions,
         id,
+        templateOptions,
         ...restScriptOptions,
     }, sucraseOptions = {
-        transforms: [...langs],
         jsxRuntime: "preserve",
+        transforms: [...langs],
     };
-    const { warnings: scriptWarnings, bindings, content, } = script || scriptSetup ? compileScript(descriptor, scriptOptions) : {};
+    const { bindings, content, warnings: scriptWarnings, } = script || scriptSetup ? compileScript(descriptor, scriptOptions) : {};
     if (bindings)
         compilerOptions.bindingMetadata = bindings;
-    const { errors: templateErrors, tips: templateTips, code, } = template && (!scriptSetup || !scriptOptions.inlineTemplate)
+    const { code, errors: templateErrors, tips: templateTips, } = template && (!scriptSetup || !scriptOptions.inlineTemplate)
         ? compileTemplate({
             ...ast,
             filename,
-            source,
             id,
+            source,
             ...templateOptions,
         })
         : {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuebro/loader-sfc",
-  "version": "2.3.14",
+  "version": "2.3.16",
   "description": "Vue3 Single File Component (SFC) loader. Load .vue files directly from your browser without any build step.",
   "keywords": [
     "vue",
@@ -41,6 +41,6 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@types/hash-sum": "^1.0.2",
     "@types/node": "^24.9.1",
-    "@vuebro/configs": "^1.1.41"
+    "@vuebro/configs": "^1.1.51"
   }
 }