@vue-jsx-vapor/macros 1.7.0

package/dist/volar.cjs

@@ -0,0 +1,394 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkUZ426MO6cjs = require('./chunk-UZ426MO6.cjs');
+
+// src/volar.ts
+var _common = require('@vue-macros/common');
+var _tsmacro = require('ts-macro');
+
+// src/volar/index.ts
+
+
+
+var _compilerdom = require('@vue/compiler-dom');
+
+
+// src/volar/define-component.ts
+
+function transformDefineComponent(node, options) {
+  const { codes, source, ast } = options;
+  _tsmacro.replaceRange.call(void 0, codes, node.arguments[0].end, node.end - 1);
+  const componentOptions = node.arguments[1];
+  _tsmacro.replaceRange.call(void 0, 
+    codes,
+    node.getStart(ast),
+    node.expression.end + 1,
+    "(",
+    [node.expression.getText(ast), source, node.getStart(ast), _tsmacro.allCodeFeatures],
+    "(() => ({}) as any, ",
+    componentOptions ? [
+      componentOptions.getText(ast),
+      source,
+      componentOptions.getStart(ast),
+      _tsmacro.allCodeFeatures
+    ] : "",
+    "), "
+  );
+}
+
+// src/volar/transform.ts
+
+
+
+// src/volar/define-style.ts
+
+var _classPropertyjs = require('@vue/language-core/lib/codegen/style/classProperty.js');
+var _parseCssClassNamesjs = require('@vue/language-core/lib/utils/parseCssClassNames.js');
+
+function transformDefineStyle(defineStyles, options) {
+  if (!_optionalChain([defineStyles, 'optionalAccess', _ => _.length])) return;
+  const { ts, codes, ast } = options;
+  defineStyles.forEach(({ expression, isCssModules }, index) => {
+    if (isCssModules && _optionalChain([expression, 'optionalAccess', _2 => _2.arguments, 'access', _3 => _3[0]]) && !expression.typeArguments && ts.isTemplateLiteral(expression.arguments[0])) {
+      _tsmacro.replaceRange.call(void 0, 
+        codes,
+        expression.arguments.pos - 1,
+        expression.arguments.pos - 1,
+        `<${_common.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 [..._parseCssClassNamesjs.parseCssClassNames.call(void 0, css)]) {
+    yield* _classPropertyjs.generateClassProperty.call(void 0, 
+      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 (!_optionalChain([root, 'optionalAccess', _4 => _4.body])) continue;
+    const asyncModifier = _optionalChain([root, 'access', _5 => _5.modifiers, 'optionalAccess', _6 => _6.find, 'call', _7 => _7(
+      (modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword
+    )]);
+    if (asyncModifier && map.defineComponent)
+      _tsmacro.replaceRange.call(void 0, codes, asyncModifier.pos, asyncModifier.end);
+    const result = `({}) as __VLS_PickNotAny<Awaited<ReturnType<typeof ${_common.HELPER_PREFIX}setup>>['render'], {}> & { __ctx: Awaited<ReturnType<typeof ${_common.HELPER_PREFIX}setup>> }`;
+    const propsType = _optionalChain([root, 'access', _8 => _8.parameters, 'access', _9 => _9[0], 'optionalAccess', _10 => _10.type]) ? String(root.parameters[0].type.getText(ast)) : "{}";
+    _tsmacro.replaceRange.call(void 0, 
+      codes,
+      root.parameters.pos,
+      root.parameters.pos,
+      ts.isArrowFunction(root) && root.parameters.pos === root.pos ? "(" : "",
+      `${_common.HELPER_PREFIX}props: Awaited<ReturnType<typeof ${_common.HELPER_PREFIX}setup>>['props'] & ${propsType}, `,
+      `${_common.HELPER_PREFIX}placeholder?: {}, `,
+      `${_common.HELPER_PREFIX}setup = (${asyncModifier ? "async" : ""}(`
+    );
+    if (ts.isArrowFunction(root)) {
+      _tsmacro.replaceRange.call(void 0, 
+        codes,
+        root.end,
+        root.end,
+        `))${root.pos === root.parameters.pos ? ")" : ""} => `,
+        result
+      );
+    } else {
+      _tsmacro.replaceRange.call(void 0, 
+        codes,
+        root.body.getStart(ast),
+        root.body.getStart(ast),
+        "=>"
+      );
+      _tsmacro.replaceRange.call(void 0, codes, root.end, root.end, `)){ return `, result, "}");
+    }
+    ts.forEachChild(root.body, (node) => {
+      if (ts.isReturnStatement(node) && node.expression) {
+        const props = [..._nullishCoalesce(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;
+        _tsmacro.replaceRange.call(void 0, 
+          codes,
+          node.getStart(ast),
+          node.expression.getStart(ast),
+          `return {
+props: {} as { ${props.join(", ")} }`,
+          `,
+slots: {} as ${_nullishCoalesce(map.defineSlots, () => ( "{}"))}`,
+          `,
+expose: (exposed: ${options.lib === "vue" ? `import('vue').ShallowUnwrapRef` : "NonNullable"}<${_nullishCoalesce(map.defineExpose, () => ( "{}"))}>) => {}`,
+          `,
+render: `,
+          shouldWrapByCall ? "(" : ""
+        );
+        _tsmacro.replaceRange.call(void 0, 
+          codes,
+          node.expression.end,
+          node.expression.end,
+          shouldWrapByCall ? ")()" : "",
+          `
+}`
+        );
+      }
+    });
+  }
+}
+
+// src/volar/global-types.ts
+
+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: ${_common.HELPER_PREFIX}StyleArgs): T; scss: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T; sass: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T; stylus: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T; less: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T; postcss: <T>(...args: ${_common.HELPER_PREFIX}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 ${_common.HELPER_PREFIX}StyleArgs = [style: string, options?: { scoped?: boolean }];
+type ${_common.HELPER_PREFIX}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) {
+          _tsmacro.replaceRange.call(void 0, 
+            codes,
+            modelOptions.end - 1,
+            modelOptions.end - 1,
+            `${!modelOptions.properties.hasTrailingComma && modelOptions.properties.length ? "," : ""} required: true`
+          );
+        }
+      } else if (isRequired) {
+        _tsmacro.replaceRange.call(void 0, 
+          codes,
+          expression.arguments.end,
+          expression.arguments.end,
+          `${!expression.arguments.hasTrailingComma && expression.arguments.length ? "," : ""} { required: true }`
+        );
+      }
+      const id = _compilerdom.toValidAssetId.call(void 0, modelName, `${_common.HELPER_PREFIX}model`);
+      const typeString = `import('vue').UnwrapRef<typeof ${id}>`;
+      (rootMap.get(root).defineModel ??= []).push(
+        `${modelName.includes("-") ? `'${modelName}'` : modelName}${isRequired ? ":" : "?:"} ${typeString}`,
+        `'onUpdate:${modelName}'?: ($event: ${typeString}) => any`
+      );
+      _tsmacro.replaceRange.call(void 0, 
+        codes,
+        initializer.getStart(ast),
+        initializer.getStart(ast),
+        `// @ts-ignore
+${id};
+let ${id} =`
+      );
+    } else if (options.defineSlots.alias.includes(macroName)) {
+      _tsmacro.replaceRange.call(void 0, 
+        codes,
+        expression.getStart(ast),
+        expression.getStart(ast),
+        `// @ts-ignore
+${_common.HELPER_PREFIX}slots;
+const ${_common.HELPER_PREFIX}slots = `
+      );
+      rootMap.get(root).defineSlots = `Partial<typeof ${_common.HELPER_PREFIX}slots>`;
+    } else if (options.defineExpose.alias.includes(macroName)) {
+      _tsmacro.replaceRange.call(void 0, 
+        codes,
+        expression.getStart(ast),
+        expression.getStart(ast),
+        `// @ts-ignore
+${_common.HELPER_PREFIX}exposed;
+const ${_common.HELPER_PREFIX}exposed = `
+      );
+      rootMap.get(root).defineExpose = `typeof ${_common.HELPER_PREFIX}exposed`;
+    }
+  }
+  ts.forEachChild(ast, (node) => walk(node, []));
+  return rootMap;
+}
+
+// src/volar.ts
+var plugin = _tsmacro.createPlugin.call(void 0, 
+  ({ ts }, userOptions = {}) => {
+    const resolvedOptions = _chunkUZ426MO6cjs.resolveOptions.call(void 0, userOptions);
+    const filter = _common.createFilter.call(void 0, 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;
+
+
+exports.default = volar_default;
+
+module.exports = exports.default;

package/dist/volar.d.cts

@@ -0,0 +1,7 @@
+import { PluginReturn } from 'ts-macro';
+import { Options } from './options.cjs';
+import '@vue-macros/common';
+
+declare const plugin: PluginReturn<Options | undefined>;
+
+export = plugin;

package/dist/volar.d.ts

@@ -0,0 +1,7 @@
+import { PluginReturn } from 'ts-macro';
+import { Options } from './options.js';
+import '@vue-macros/common';
+
+declare const plugin: PluginReturn<Options | undefined>;
+
+export { plugin as default };