@vue-jsx-vapor/macros 1.7.0

package/dist/volar.js

@@ -0,0 +1,392 @@
+import {
+  resolveOptions
+} from "./chunk-ZXRSELD6.js";
+
+// src/volar.ts
+import { createFilter } from "@vue-macros/common";
+import { createPlugin } from "ts-macro";
+
+// src/volar/index.ts
+import {
+  HELPER_PREFIX as HELPER_PREFIX4
+} from "@vue-macros/common";
+import { toValidAssetId } from "@vue/compiler-dom";
+import { replaceRange as replaceRange4 } from "ts-macro";
+
+// src/volar/define-component.ts
+import { allCodeFeatures, replaceRange } from "ts-macro";
+function transformDefineComponent(node, options) {
+  const { codes, source, ast } = options;
+  replaceRange(codes, node.arguments[0].end, node.end - 1);
+  const componentOptions = node.arguments[1];
+  replaceRange(
+    codes,
+    node.getStart(ast),
+    node.expression.end + 1,
+    "(",
+    [node.expression.getText(ast), source, node.getStart(ast), allCodeFeatures],
+    "(() => ({}) as any, ",
+    componentOptions ? [
+      componentOptions.getText(ast),
+      source,
+      componentOptions.getStart(ast),
+      allCodeFeatures
+    ] : "",
+    "), "
+  );
+}
+
+// src/volar/transform.ts
+import { HELPER_PREFIX as HELPER_PREFIX2 } from "@vue-macros/common";
+import { replaceRange as replaceRange3 } from "ts-macro";
+
+// src/volar/define-style.ts
+import { HELPER_PREFIX } from "@vue-macros/common";
+import { generateClassProperty } from "@vue/language-core/lib/codegen/style/classProperty.js";
+import { parseCssClassNames } from "@vue/language-core/lib/utils/parseCssClassNames.js";
+import { replaceRange as replaceRange2 } from "ts-macro";
+function transformDefineStyle(defineStyles, options) {
+  if (!defineStyles?.length) return;
+  const { ts, codes, ast } = options;
+  defineStyles.forEach(({ expression, isCssModules }, index) => {
+    if (isCssModules && expression?.arguments[0] && !expression.typeArguments && ts.isTemplateLiteral(expression.arguments[0])) {
+      replaceRange2(
+        codes,
+        expression.arguments.pos - 1,
+        expression.arguments.pos - 1,
+        `<${HELPER_PREFIX}PrettifyLocal<{}`,
+        ...generateCssClassesType(
+          expression.arguments[0].getText(ast).slice(1, -1),
+          expression.arguments[0].getStart(ast) + 1,
+          index
+        ),
+        ">>"
+      );
+    }
+    addEmbeddedCode(expression, index, options);
+  });
+}
+function* generateCssClassesType(css, offset, index) {
+  for (const className of [...parseCssClassNames(css)]) {
+    yield* generateClassProperty(
+      index,
+      className.text,
+      className.offset + offset,
+      "string"
+    );
+  }
+}
+function addEmbeddedCode(expression, index, options) {
+  const { ts, ast } = options;
+  const languageId = ts.isPropertyAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.name) ? expression.expression.name.text : "css";
+  const style = expression.arguments[0];
+  const styleText = style.getText(ast).slice(1, -1).replaceAll(/\$\{.*\}/g, (str) => "_".repeat(str.length));
+  options.embeddedCodes.push({
+    id: `style_${index}`,
+    languageId,
+    snapshot: {
+      getText: (start, end) => styleText.slice(start, end),
+      getLength: () => styleText.length,
+      getChangeRange: () => void 0
+    },
+    mappings: [
+      {
+        sourceOffsets: [style.getStart(ast) + 1],
+        generatedOffsets: [0],
+        lengths: [styleText.length],
+        data: {
+          completion: true,
+          format: true,
+          navigation: true,
+          semantic: true,
+          structure: true,
+          verification: true
+        }
+      }
+    ],
+    embeddedCodes: []
+  });
+}
+
+// src/volar/transform.ts
+function transformJsxMacros(rootMap, options) {
+  const { ts, codes, ast } = options;
+  for (const [root, map] of rootMap) {
+    transformDefineStyle(map.defineStyle, options);
+    if (!root?.body) continue;
+    const asyncModifier = root.modifiers?.find(
+      (modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword
+    );
+    if (asyncModifier && map.defineComponent)
+      replaceRange3(codes, asyncModifier.pos, asyncModifier.end);
+    const result = `({}) as __VLS_PickNotAny<Awaited<ReturnType<typeof ${HELPER_PREFIX2}setup>>['render'], {}> & { __ctx: Awaited<ReturnType<typeof ${HELPER_PREFIX2}setup>> }`;
+    const propsType = root.parameters[0]?.type ? String(root.parameters[0].type.getText(ast)) : "{}";
+    replaceRange3(
+      codes,
+      root.parameters.pos,
+      root.parameters.pos,
+      ts.isArrowFunction(root) && root.parameters.pos === root.pos ? "(" : "",
+      `${HELPER_PREFIX2}props: Awaited<ReturnType<typeof ${HELPER_PREFIX2}setup>>['props'] & ${propsType}, `,
+      `${HELPER_PREFIX2}placeholder?: {}, `,
+      `${HELPER_PREFIX2}setup = (${asyncModifier ? "async" : ""}(`
+    );
+    if (ts.isArrowFunction(root)) {
+      replaceRange3(
+        codes,
+        root.end,
+        root.end,
+        `))${root.pos === root.parameters.pos ? ")" : ""} => `,
+        result
+      );
+    } else {
+      replaceRange3(
+        codes,
+        root.body.getStart(ast),
+        root.body.getStart(ast),
+        "=>"
+      );
+      replaceRange3(codes, root.end, root.end, `)){ return `, result, "}");
+    }
+    ts.forEachChild(root.body, (node) => {
+      if (ts.isReturnStatement(node) && node.expression) {
+        const props = [...map.defineModel ?? []];
+        const elements = root.parameters[0] && !root.parameters[0].type && ts.isObjectBindingPattern(root.parameters[0].name) ? root.parameters[0].name.elements : [];
+        for (const element of elements) {
+          if (ts.isIdentifier(element.name))
+            props.push(
+              `${element.name.escapedText}${element.initializer && ts.isNonNullExpression(element.initializer) ? ":" : "?:"} typeof ${element.name.escapedText}`
+            );
+        }
+        const shouldWrapByCall = (ts.isArrowFunction(node.expression) || ts.isFunctionExpression(node.expression)) && map.defineComponent;
+        replaceRange3(
+          codes,
+          node.getStart(ast),
+          node.expression.getStart(ast),
+          `return {
+props: {} as { ${props.join(", ")} }`,
+          `,
+slots: {} as ${map.defineSlots ?? "{}"}`,
+          `,
+expose: (exposed: ${options.lib === "vue" ? `import('vue').ShallowUnwrapRef` : "NonNullable"}<${map.defineExpose ?? "{}"}>) => {}`,
+          `,
+render: `,
+          shouldWrapByCall ? "(" : ""
+        );
+        replaceRange3(
+          codes,
+          node.expression.end,
+          node.expression.end,
+          shouldWrapByCall ? ")()" : "",
+          `
+}`
+        );
+      }
+    });
+  }
+}
+
+// src/volar/global-types.ts
+import { HELPER_PREFIX as HELPER_PREFIX3 } from "@vue-macros/common";
+function getGlobalTypes(options) {
+  const defineSlots = options.defineSlots.alias.flatMap((alias) => [
+    `declare function ${alias}<T extends Record<string, any>>(): Partial<T>;`,
+    `declare function ${alias}<T extends Record<string, any>>(slots: T): T;
+`
+  ]).join("");
+  const defineExpose = options.defineExpose.alias.map(
+    (alias) => `declare function ${alias}<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): Exposed;`
+  ).join("");
+  const defineStyle = options.defineStyle.alias.map(
+    (alias) => `declare const ${alias}: { <T>(...args: ${HELPER_PREFIX3}StyleArgs): T; scss: <T>(...args: ${HELPER_PREFIX3}StyleArgs)=> T; sass: <T>(...args: ${HELPER_PREFIX3}StyleArgs)=> T; stylus: <T>(...args: ${HELPER_PREFIX3}StyleArgs)=> T; less: <T>(...args: ${HELPER_PREFIX3}StyleArgs)=> T; postcss: <T>(...args: ${HELPER_PREFIX3}StyleArgs)=> T };
+`
+  ).join("");
+  const defineModel = options.defineModel.alias.map(
+    (alias) => alias === "defineModel" ? "defineModel" : `defineModel: ${alias}`
+  ).join(", ");
+  const defineComponent = options.defineComponent.alias.map(
+    (alias) => ["defineComponent", "defineVaporComponent"].includes(alias) ? "" : `defineComponent: ${alias}`
+  ).filter(Boolean).join(", ");
+  return `
+declare const { ${defineModel}, ${defineComponent} }: typeof import('vue')
+${defineSlots}
+${defineExpose}
+${defineStyle}
+type ${HELPER_PREFIX3}StyleArgs = [style: string, options?: { scoped?: boolean }];
+type ${HELPER_PREFIX3}PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {};
+// @ts-ignore
+type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
+// @ts-ignore
+type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
+`;
+}
+
+// src/volar/index.ts
+function getMacro(node, ts, options) {
+  if (!node) return;
+  if (ts.isVariableStatement(node)) {
+    return ts.forEachChild(node.declarationList, (decl) => getExpression(decl));
+  } else {
+    return getExpression(node);
+  }
+  function getExpression(decl) {
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+      const initializer = ts.isCallExpression(decl.initializer) && ts.isIdentifier(decl.initializer.expression) && decl.initializer.expression.escapedText === "$" && decl.initializer.arguments[0] ? decl.initializer.arguments[0] : decl.initializer;
+      const expression = getMacroExpression(initializer);
+      if (expression) {
+        return {
+          expression,
+          initializer: decl.initializer,
+          isRequired: ts.isNonNullExpression(initializer)
+        };
+      }
+    } else if (ts.isExpressionStatement(decl)) {
+      const expression = getMacroExpression(decl.expression);
+      if (expression)
+        return {
+          expression,
+          initializer: decl.expression,
+          isRequired: ts.isNonNullExpression(decl.expression)
+        };
+    }
+  }
+  function getMacroExpression(node2) {
+    if (ts.isNonNullExpression(node2)) {
+      node2 = node2.expression;
+    }
+    if (!ts.isCallExpression(node2)) return;
+    const expression = ts.isPropertyAccessExpression(node2.expression) ? node2.expression : node2;
+    return ts.isIdentifier(expression.expression) && [
+      ...options.defineModel.alias,
+      ...options.defineSlots.alias,
+      ...options.defineStyle.alias,
+      ...options.defineExpose.alias,
+      ...options.defineComponent.alias
+    ].includes(expression.expression.escapedText) && node2;
+  }
+}
+function getRootMap(options) {
+  const { ts, ast, codes } = options;
+  const rootMap = /* @__PURE__ */ new Map();
+  function walk(node, parents) {
+    ts.forEachChild(node, (child) => {
+      parents.unshift(node);
+      walk(child, parents);
+      parents.shift();
+    });
+    const root = parents[1] && (ts.isArrowFunction(parents[1]) || ts.isFunctionExpression(parents[1]) || ts.isFunctionDeclaration(parents[1])) ? parents[1] : void 0;
+    if (root && parents[2] && ts.isCallExpression(parents[2]) && !parents[2].typeArguments && options.defineComponent.alias.includes(parents[2].expression.getText(ast))) {
+      if (!rootMap.has(root)) rootMap.set(root, {});
+      if (!rootMap.get(root).defineComponent) {
+        rootMap.get(root).defineComponent = true;
+        transformDefineComponent(parents[2], options);
+      }
+    }
+    const macro = getMacro(node, ts, options);
+    if (!macro) return;
+    const { expression, initializer } = macro;
+    let isRequired = macro.isRequired;
+    if (!rootMap.has(root)) rootMap.set(root, {});
+    const macroName = expression.expression.getText(ast);
+    if (macroName.startsWith("defineStyle")) {
+      ;
+      (rootMap.get(root).defineStyle ??= []).push({
+        expression,
+        isCssModules: !!ts.isVariableStatement(node)
+      });
+    }
+    if (!root) return;
+    if (options.defineModel.alias.includes(macroName)) {
+      const modelName = expression.arguments[0] && ts.isStringLiteralLike(expression.arguments[0]) ? expression.arguments[0].text : "modelValue";
+      const modelOptions = expression.arguments[0] && ts.isStringLiteralLike(expression.arguments[0]) ? expression.arguments[1] : expression.arguments[0];
+      if (modelOptions && ts.isObjectLiteralExpression(modelOptions)) {
+        let hasRequired = false;
+        for (const prop of modelOptions.properties) {
+          if (ts.isPropertyAssignment(prop) && prop.name.getText(ast) === "required") {
+            hasRequired = true;
+            isRequired = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+          }
+        }
+        if (!hasRequired && isRequired) {
+          replaceRange4(
+            codes,
+            modelOptions.end - 1,
+            modelOptions.end - 1,
+            `${!modelOptions.properties.hasTrailingComma && modelOptions.properties.length ? "," : ""} required: true`
+          );
+        }
+      } else if (isRequired) {
+        replaceRange4(
+          codes,
+          expression.arguments.end,
+          expression.arguments.end,
+          `${!expression.arguments.hasTrailingComma && expression.arguments.length ? "," : ""} { required: true }`
+        );
+      }
+      const id = toValidAssetId(modelName, `${HELPER_PREFIX4}model`);
+      const typeString = `import('vue').UnwrapRef<typeof ${id}>`;
+      (rootMap.get(root).defineModel ??= []).push(
+        `${modelName.includes("-") ? `'${modelName}'` : modelName}${isRequired ? ":" : "?:"} ${typeString}`,
+        `'onUpdate:${modelName}'?: ($event: ${typeString}) => any`
+      );
+      replaceRange4(
+        codes,
+        initializer.getStart(ast),
+        initializer.getStart(ast),
+        `// @ts-ignore
+${id};
+let ${id} =`
+      );
+    } else if (options.defineSlots.alias.includes(macroName)) {
+      replaceRange4(
+        codes,
+        expression.getStart(ast),
+        expression.getStart(ast),
+        `// @ts-ignore
+${HELPER_PREFIX4}slots;
+const ${HELPER_PREFIX4}slots = `
+      );
+      rootMap.get(root).defineSlots = `Partial<typeof ${HELPER_PREFIX4}slots>`;
+    } else if (options.defineExpose.alias.includes(macroName)) {
+      replaceRange4(
+        codes,
+        expression.getStart(ast),
+        expression.getStart(ast),
+        `// @ts-ignore
+${HELPER_PREFIX4}exposed;
+const ${HELPER_PREFIX4}exposed = `
+      );
+      rootMap.get(root).defineExpose = `typeof ${HELPER_PREFIX4}exposed`;
+    }
+  }
+  ts.forEachChild(ast, (node) => walk(node, []));
+  return rootMap;
+}
+
+// src/volar.ts
+var plugin = createPlugin(
+  ({ ts }, userOptions = {}) => {
+    const resolvedOptions = resolveOptions(userOptions);
+    const filter = createFilter(resolvedOptions);
+    return {
+      name: "@vue-jsx-vapor/macros",
+      resolveVirtualCode(virtualCode) {
+        const { filePath, codes } = virtualCode;
+        if (!filter(filePath)) return;
+        const options = {
+          ts,
+          ...virtualCode,
+          ...resolvedOptions
+        };
+        const rootMap = getRootMap(options);
+        if (rootMap.size) {
+          transformJsxMacros(rootMap, options);
+          codes.push(getGlobalTypes(options));
+        }
+      }
+    };
+  }
+);
+var volar_default = plugin;
+export {
+  volar_default as default
+};

package/dist/webpack.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkXA5RNEABcjs = require('./chunk-XA5RNEAB.cjs');
+require('./chunk-Y4BCVHJT.cjs');
+require('./chunk-LYT252SL.cjs');
+require('./chunk-6JTF6MNY.cjs');
+require('./chunk-UZ426MO6.cjs');
+
+
+exports.default = _chunkXA5RNEABcjs.webpack_default;
+
+module.exports = exports.default;

package/dist/webpack.d.cts

@@ -0,0 +1,7 @@
+import * as webpack from 'webpack';
+import { Options } from './options.cjs';
+import '@vue-macros/common';
+
+declare const _default: (options?: Options | undefined) => webpack.WebpackPluginInstance;
+
+export = _default;

package/dist/webpack.d.ts

@@ -0,0 +1,7 @@
+import * as webpack from 'webpack';
+import { Options } from './options.js';
+import '@vue-macros/common';
+
+declare const _default: (options?: Options | undefined) => webpack.WebpackPluginInstance;
+
+export { _default as default };

package/dist/webpack.js

@@ -0,0 +1,10 @@
+import {
+  webpack_default
+} from "./chunk-7SOTCEEO.js";
+import "./chunk-IXJAH75Q.js";
+import "./chunk-UCG5RA54.js";
+import "./chunk-KDEA57GU.js";
+import "./chunk-ZXRSELD6.js";
+export {
+  webpack_default as default
+};

package/package.json

@@ -0,0 +1,191 @@
+{
+  "name": "@vue-jsx-vapor/macros",
+  "version": "1.7.0",
+  "description": "Macros for Vue JSX Vapor",
+  "type": "module",
+  "keywords": [
+    "transform",
+    "vue-jsx",
+    "macros",
+    "volar",
+    "vapor"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/unplugin/unplugin-vue-jsx-vapor#readme",
+  "bugs": {
+    "url": "https://github.com/unplugin/unplugin-vue-jsx-vapor/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unplugin/unplugin-vue-jsx-vapor.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "dev": "./src/index.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./astro": {
+      "dev": "./src/astro.ts",
+      "require": "./dist/astro.cjs",
+      "import": "./dist/astro.js"
+    },
+    "./rspack": {
+      "dev": "./src/rspack.ts",
+      "require": "./dist/rspack.cjs",
+      "import": "./dist/rspack.js"
+    },
+    "./vite": {
+      "dev": "./src/vite.ts",
+      "require": "./dist/vite.cjs",
+      "import": "./dist/vite.js"
+    },
+    "./webpack": {
+      "dev": "./src/webpack.ts",
+      "require": "./dist/webpack.cjs",
+      "import": "./dist/webpack.js"
+    },
+    "./rollup": {
+      "dev": "./src/rollup.ts",
+      "require": "./dist/rollup.cjs",
+      "import": "./dist/rollup.js"
+    },
+    "./esbuild": {
+      "dev": "./src/esbuild.ts",
+      "require": "./dist/esbuild.cjs",
+      "import": "./dist/esbuild.js"
+    },
+    "./nuxt": {
+      "dev": "./src/nuxt.ts",
+      "require": "./dist/nuxt.cjs",
+      "import": "./dist/nuxt.js"
+    },
+    "./api": {
+      "dev": "./src/api.ts",
+      "require": "./dist/api.cjs",
+      "import": "./dist/api.js"
+    },
+    "./raw": {
+      "dev": "./src/raw.ts",
+      "require": "./dist/raw.cjs",
+      "import": "./dist/raw.js"
+    },
+    "./volar": {
+      "dev": "./src/volar.ts",
+      "require": "./dist/volar.cjs",
+      "import": "./dist/volar.js"
+    },
+    "./*": "./*"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./*"
+      ]
+    }
+  },
+  "publishConfig": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./astro": {
+      "require": "./dist/astro.cjs",
+      "import": "./dist/astro.js"
+    },
+    "./rspack": {
+      "require": "./dist/rspack.cjs",
+      "import": "./dist/rspack.js"
+    },
+    "./vite": {
+      "require": "./dist/vite.cjs",
+      "import": "./dist/vite.js"
+    },
+    "./webpack": {
+      "require": "./dist/webpack.cjs",
+      "import": "./dist/webpack.js"
+    },
+    "./rollup": {
+      "require": "./dist/rollup.cjs",
+      "import": "./dist/rollup.js"
+    },
+    "./esbuild": {
+      "require": "./dist/esbuild.cjs",
+      "import": "./dist/esbuild.js"
+    },
+    "./nuxt": {
+      "require": "./dist/nuxt.cjs",
+      "import": "./dist/nuxt.js"
+    },
+    "./api": {
+      "require": "./dist/api.cjs",
+      "import": "./dist/api.js"
+    },
+    "./raw": {
+      "require": "./dist/raw.cjs",
+      "import": "./dist/raw.js"
+    },
+    "./volar": {
+      "require": "./dist/volar.cjs",
+      "import": "./dist/volar.js"
+    },
+    "./*": "./*"
+  },
+  "peerDependencies": {
+    "@nuxt/kit": "^3",
+    "@nuxt/schema": "^3",
+    "esbuild": "*",
+    "rollup": "^3",
+    "vite": ">=3",
+    "webpack": "^4 || ^5"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/kit": {
+      "optional": true
+    },
+    "@nuxt/schema": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "rollup": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "webpack": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@vue-macros/common": "3.0.0-beta.4",
+    "@vue/compiler-dom": "https://pkg.pr.new/@vue/compiler-dom@ce35a8c",
+    "@vue/compiler-sfc": "https://pkg.pr.new/@vue/compiler-sfc@ce35a8c",
+    "@vue/language-core": "^2.2.8",
+    "hash-sum": "^2.0.0",
+    "ts-macro": "0.1.21",
+    "unplugin": "^1.16.1"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.26.8",
+    "@nuxt/kit": "^3.16.0",
+    "@nuxt/schema": "^3.16.0",
+    "@types/hash-sum": "^1.0.2",
+    "@vue-macros/test-utils": "3.0.0-beta.4",
+    "vitest": "^3.0.8",
+    "vue": "https://pkg.pr.new/vue@ce35a8c"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "DEV=true tsup"
+  }
+}