')
36 | expect(transformedCode).toMatch('
{new __Decimal(0.1).plus(0.2).toNumber()}
')
37 | })
38 | it(`
39 | tsx block-ad-ignore
40 | input:
41 |
{0.1 + 0.2}
42 | output:
43 |
{0.1 + 0.2}
44 | `, () => {
45 | expect(transformedCode).toMatch('
{0.1 + 0.2}')
46 | })
47 | it(`
48 | tsx next-ad-ignore
49 | input:
50 | {/* next-ad-ignore */}
51 |
{0.1 + 0.2}
52 | output:
53 |
{new __Decimal(0.1).plus(0.2).toNumber()}
54 | `, () => {
55 | expect(transformedCode).toMatch('
{new __Decimal(0.1).plus(0.2).toNumber()}
')
56 | })
57 | it(`
58 | tsx next-ad-ignore multiple
59 | input:
60 | {/* next-ad-ignore */}
61 | skip: {0.1 + 0.2} transform: {1 - 0.9}
62 | output:
63 | skip: {0.1 + 0.2} transform: {1 - 0.9}
64 | `, () => {
65 | expect(transformedCode).toMatch('skip: {0.1 + 0.2} transform: {1 - 0.9}')
66 | })
67 | }
68 | })
69 |
--------------------------------------------------------------------------------
/examples/vite-react/src/logo.svg:
--------------------------------------------------------------------------------
1 |
8 |
--------------------------------------------------------------------------------
/test/to-decimal.test.ts:
--------------------------------------------------------------------------------
1 | import { promises as fs } from 'node:fs'
2 | import { resolve } from 'node:path'
3 | import fastGlob from 'fast-glob'
4 | import { describe, expect, it } from 'vitest'
5 | import { transform } from '../src/core/unplugin'
6 |
7 | describe('transform', async () => {
8 | const root = resolve(__dirname, 'fixtures')
9 | const files = await fastGlob('to-decimal.ts', {
10 | cwd: root,
11 | onlyFiles: true,
12 | })
13 | for (const file of files) {
14 | const fixture = await fs.readFile(resolve(root, file), 'utf-8')
15 | const transformedCode = transform(fixture, file, {
16 | supportString: false,
17 | tailPatchZero: false,
18 | package: 'decimal.js-light',
19 | toDecimal: true,
20 | dts: false,
21 | decimalName: '__Decimal',
22 | supportNewFunction: false,
23 | })?.code ?? fixture
24 | it(`
25 | ts
26 | input:
27 | const _a = 0.1 + 0.2.toDecimal()
28 | output:
29 | const _a = new __Decimal(0.1).plus(0.2).toNumber()
30 | `, () => {
31 | expect(transformedCode).toMatch('const _a = new __Decimal(0.1).plus(0.2).toNumber()')
32 | })
33 | it(`
34 | ts _test()
35 | input:
36 | function _test() {
37 | const _ad = 0.111 + 0.222.toDecimal({ precision: 3, callMethod: 'toFixed' })
38 | }
39 | output:
40 | function _test() {
41 | const _ad = new __Decimal(0.111).plus(0.222).toFixed(3, 4)
42 | }
43 | `, () => {
44 | expect(transformedCode).toMatch('const _ad = new __Decimal(0.111).plus(0.222).toFixed(3, 4)')
45 | })
46 | it(`
47 | ts Class
48 | input:
49 | constructor() {
50 | this.block = 0.1 + 0.2.toDecimal()
51 | }
52 | output:
53 | constructor() {
54 | this.block = new __Decimal(0.1).plus(0.2).toNumber()
55 | }
56 | `, () => {
57 | expect(transformedCode).toMatch('this.block = new __Decimal(0.1).plus(0.2).toNumber()')
58 | })
59 | it(`
60 | ts Array
61 | input:
62 | const _arr = [0, 0.1 + 0.2.toDecimal({ callMethod: 'toString' }), 3]
63 | output:
64 | const _arr = [0, new __Decimal(0.1).plus(0.2).toString(), 3]
65 | `, () => {
66 | expect(transformedCode).toMatch('const _arr = [0, new __Decimal(0.1).plus(0.2).toString(), 3]')
67 | })
68 | it(`
69 | ts return decimal
70 | input:
71 | const _toDecimal = (0.111 + 0.222).toDecimal({ callMethod: 'decimal' })
72 | output:
73 | const _toDecimal = new __Decimal(0.111).plus(0.222)
74 | `, () => {
75 | expect(transformedCode).toMatch('const _toDecimal = new __Decimal(0.111).plus(0.222)')
76 | })
77 | }
78 | })
79 |
--------------------------------------------------------------------------------
/test/new-function-to-decimal.test.ts:
--------------------------------------------------------------------------------
1 | import { promises as fs } from 'node:fs'
2 | import { resolve } from 'node:path'
3 | import fastGlob from 'fast-glob'
4 | import { describe, expect, it } from 'vitest'
5 | import { resolveOptions } from '../src/core/options'
6 | import { transform } from '../src/core/unplugin'
7 |
8 | describe('transform', async () => {
9 | const root = resolve(__dirname, 'fixtures')
10 | const files = await fastGlob('new-function-to-decimal.ts', {
11 | cwd: root,
12 | onlyFiles: true,
13 | })
14 | for (const file of files) {
15 | const fixture = await fs.readFile(resolve(root, file), 'utf-8')
16 | const transformedCode = transform(fixture, file, resolveOptions({
17 | supportString: true,
18 | tailPatchZero: false,
19 | package: 'decimal.js-light',
20 | toDecimal: true,
21 | dts: false,
22 | decimalName: '__Decimal',
23 | supportNewFunction: true,
24 | }))?.code ?? fixture
25 | it(`
26 | new Function toDecimal
27 | input:
28 | const returnedValue = () => 'return a + b + 3'
29 | output:
30 | const returnedValue = () => 'return a + b + 3'
31 | `, () => {
32 | expect(transformedCode).toMatch(`const returnedValue = () => 'return a + b + 3'`)
33 | })
34 | it(`
35 | new Function toDecimal
36 | input:
37 | return 'return a + b + 4..toDecimal()'
38 | output:
39 | return 'return new __Decimal(a).plus(b).plus(4.).toNumber()'
40 | `, () => {
41 | expect(transformedCode).toMatch(`return 'return new __Decimal(a).plus(b).plus(4.).toNumber()'`)
42 | })
43 | it(`
44 | new Function Array
45 | input:
46 | const arr = [1, new Function('a', 'b', params)]
47 | arr[1](0.1, 0.2)
48 | output:
49 | const arr = [1, new Function('a', 'b', '__Decimal', params)]
50 | arr[1](0.1, 0.2, __Decimal)
51 | `, () => {
52 | expect(transformedCode).toMatch(`const arr = [1, new Function('a', 'b', '__Decimal', params)]`)
53 | expect(transformedCode).toMatch(`arr[1](0.1, 0.2, __Decimal)`)
54 | })
55 | it(`
56 | new Function Object
57 | input:
58 | const obj = { b: new Function('a', 'b', params) }
59 | obj.b(num, 0.2))
60 | output:
61 | const obj = { b: new Function('a', 'b', '__Decimal', params) }
62 | obj.b(num, 0.2, __Decimal))
63 | `, () => {
64 | expect(transformedCode).toMatch(`const obj = { b: new Function('a', 'b', '__Decimal', params) }`)
65 | expect(transformedCode).toMatch(`obj.b(num, 0.2, __Decimal))`)
66 | })
67 | it(`
68 | new Function Call Function
69 | input:
70 | const callFn = fn(num, 0.2)
71 | output:
72 | const callFn = fn(num, 0.2, __Decimal)
73 | `, () => {
74 | expect(transformedCode).toMatch(`const callFn = fn(num, 0.2, __Decimal)`)
75 | })
76 | }
77 | })
78 |
--------------------------------------------------------------------------------
/src/types.ts:
--------------------------------------------------------------------------------
1 | import type { NodePath } from '@babel/traverse'
2 | import type { MagicStringAST } from 'magic-string-ast'
3 | import type { BIG_RM, DECIMAL_RM, DECIMAL_RM_LIGHT } from './core/constant'
4 |
5 | export interface AutoDecimal {}
6 | export interface Options {
7 | shouldSkip: boolean
8 | msa: MagicStringAST
9 | imported: boolean
10 | decimalPkgName: string
11 | initial: boolean
12 | callMethod: CallMethod
13 | callArgs: string
14 | autoDecimalOptions: InnerAutoDecimalOptions
15 | integer: boolean
16 | fromNewFunction?: boolean
17 | needImport?: boolean
18 | ownerPath?: NodePath
19 | }
20 | export interface ToDecimalConfig extends ToDecimalOptions {
21 | name?: string
22 | }
23 | export interface AutoDecimalOptions {
24 | supportString?: boolean
25 | tailPatchZero?: boolean
26 | package?: Package
27 | toDecimal?: boolean | ToDecimalConfig
28 | dts?: boolean | string
29 | decimalName?: string
30 | supportNewFunction?: boolean | NewFunctionOptions
31 | }
32 | export type InnerAutoDecimalOptions = Required
33 | export interface ToDecimalOptions {
34 | callMethod?: CallMethod
35 | /** callMethod */
36 | cm?: CallMethod
37 | precision?: number
38 | /** precision */
39 | p?: number
40 | roundingModes?: RoundingModes | number
41 | /** roundingModes */
42 | rm?: RoundingModes | number
43 | }
44 | export type InnerToDecimalOptions = Required
45 | export type ToDecimal = (options?: T) => ToDecimalReturn
46 | export interface Extra {
47 | __extra: Record
48 | options: Options
49 | __shouldTransform: boolean
50 | }
51 |
52 | export type CallMethod = 'toNumber' | 'toString' | 'toFixed' | 'decimal'
53 | export type Package = 'decimal.js' | 'decimal.js-light' | 'big.js'
54 | export type ToDecimalReturn = GetToDecimalReturn | GetToDecimalReturn
55 | // @ts-expect-error support extend
56 | export type RoundingModes = AutoDecimal['package'] extends 'big.js'
57 | ? BigRoundingMode
58 | // @ts-expect-error support extend
59 | : AutoDecimal['package'] extends 'decimal.js'
60 | ? DecimalRoundingMode
61 | : DecimalLightRoundingMode
62 | export type DecimalRoundingMode = keyof typeof DECIMAL_RM
63 | export type DecimalLightRoundingMode = keyof typeof DECIMAL_RM_LIGHT
64 | export type BigRoundingMode = keyof typeof BIG_RM
65 | export type Operator = '+' | '-' | '*' | '/'
66 | export interface CommentState {
67 | line: number
68 | block: boolean
69 | next: boolean
70 | }
71 | export interface NewFunctionOptions {
72 | toDecimal?: boolean | ToDecimalConfig
73 | injectWindow?: string
74 | }
75 | type GetToDecimalReturn = V extends keyof T
76 | ? T[V] extends 'toFixed' | 'toString'
77 | ? string
78 | : T[V] extends 'decimal'
79 | // @ts-expect-error support extend interface
80 | ? AutoDecimal['decimal']
81 | : number
82 | : never
83 |
--------------------------------------------------------------------------------
/src/core/traverse/ast.ts:
--------------------------------------------------------------------------------
1 | import type { TraverseOptions } from '@babel/traverse'
2 | import type { File } from '@babel/types'
3 | import type { Options } from '../../types'
4 | import { isJSXEmptyExpression } from '@babel/types'
5 | import { BLOCK_COMMENT, FILE_COMMENT, PKG_NAME } from '../constant'
6 | import { resolveBinaryExpression } from './binary-expression'
7 | import { resolveCallExpression } from './call-expression'
8 | import { blockComment, innerComment, nextComment } from './comment'
9 | import { resolveExportDefaultDeclaration } from './export-declaration'
10 | import { resolveImportDeclaration } from './import-declaration'
11 | import { resolveNewFunctionExpression } from './new-function'
12 |
13 | export function traverseAst(options: Options, checkImport = true, templateImport = false): TraverseOptions {
14 | return {
15 | enter(path) {
16 | switch (path.type) {
17 | case 'Program':
18 | case 'ImportDeclaration':
19 | case 'ExportDefaultDeclaration':
20 | case 'JSXElement':
21 | case 'JSXOpeningElement':
22 | case 'JSXExpressionContainer':
23 | case 'BinaryExpression':
24 | break
25 | default:
26 | blockComment(path)
27 | nextComment(path)
28 | break
29 | }
30 | },
31 | Program: {
32 | enter(path) {
33 | const file = path.parent as File
34 | const fileIgnore = file.comments?.some(comment => comment.value.includes(FILE_COMMENT)) ?? false
35 | options.imported = fileIgnore && templateImport
36 | if (fileIgnore && !templateImport) {
37 | path.skip()
38 | }
39 | },
40 | exit() {
41 | const hasChanged = options.msa.hasChanged()
42 | if (!checkImport || options.imported || (!hasChanged && !templateImport)) {
43 | return
44 | }
45 | if (!options.needImport)
46 | return
47 | const pkgName = options.autoDecimalOptions?.package ?? PKG_NAME
48 | options.imported = true
49 | options.msa.prepend(`\nimport ${options.decimalPkgName} from '${pkgName}';\n`)
50 | },
51 | },
52 | ExportDefaultDeclaration(path) {
53 | if (!templateImport)
54 | return
55 | resolveExportDefaultDeclaration(path, options)
56 | },
57 | ImportDeclaration(path) {
58 | if (options.imported)
59 | return
60 | resolveImportDeclaration(path, options)
61 | },
62 | JSXElement: path => innerComment(path, BLOCK_COMMENT),
63 | JSXOpeningElement: (path) => {
64 | if (!path.node.attributes.length)
65 | return
66 | innerComment(path)
67 | },
68 | JSXExpressionContainer: (path) => {
69 | if (isJSXEmptyExpression(path.node.expression))
70 | return
71 | innerComment(path)
72 | },
73 | BinaryExpression: path => resolveBinaryExpression(path, options),
74 | CallExpression: path => resolveCallExpression(path, options),
75 | NewExpression: path => resolveNewFunctionExpression(path, options),
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/test/new-function.test.ts:
--------------------------------------------------------------------------------
1 | import { promises as fs } from 'node:fs'
2 | import { resolve } from 'node:path'
3 | import fastGlob from 'fast-glob'
4 | import { describe, expect, it } from 'vitest'
5 | import { transform } from '../src/core/unplugin'
6 |
7 | describe('transform', async () => {
8 | const root = resolve(__dirname, 'fixtures')
9 | const files = await fastGlob('*-function.ts', {
10 | cwd: root,
11 | onlyFiles: true,
12 | })
13 | for (const file of files) {
14 | const fixture = await fs.readFile(resolve(root, file), 'utf-8')
15 | const transformedCode = transform(fixture, file, {
16 | supportString: true,
17 | tailPatchZero: false,
18 | package: 'decimal.js-light',
19 | toDecimal: false,
20 | dts: false,
21 | decimalName: '__Decimal',
22 | supportNewFunction: true,
23 | })?.code ?? fixture
24 | it(`
25 | new Function return value
26 | input:
27 | const fn = new Function('a', 'b', \`return a + b\`)
28 | const result = fn(0.1, 0.2)
29 | output:
30 | const fn = new Function('a', 'b', '__Decimal', \`return new __Decimal(a).plus(b).toNumber()\`)
31 | const result = fn(0.1, 0.2, __Decimal)
32 | `, () => {
33 | expect(transformedCode).toMatch(`const fn = new Function('a', 'b', '__Decimal', \`return new __Decimal(a).plus(b).toNumber()\`)`)
34 | expect(transformedCode).toMatch(`const result = fn(0.1, 0.2, __Decimal)`)
35 | })
36 | it(`
37 | new Function params
38 | input:
39 | const result = fn(0.1, 0.2)
40 | output:
41 | const result = fn(0.1, 0.2, __Decimal)
42 | `, () => {
43 | expect(transformedCode).toMatch('const result = fn(0.1, 0.2, __Decimal)')
44 | })
45 | it(`
46 | new Function Array
47 | input:
48 | const arr = [1, new Function('a', 'b', params)]
49 | arr[1](0.1, 0.2)
50 | output:
51 | const arr = [1, new Function('a', 'b', '__Decimal', params)]
52 | arr[1](0.1, 0.2, __Decimal)
53 | `, () => {
54 | expect(transformedCode).toMatch(`const arr = [1, new Function('a', 'b', '__Decimal', params)]`)
55 | expect(transformedCode).toMatch(`arr[1](0.1, 0.2, __Decimal)`)
56 | })
57 | it(`
58 | new Function Object
59 | input:
60 | const obj = { b: new Function('a', 'b', params) }
61 | obj.b(num, 0.2))
62 | output:
63 | const obj = { b: new Function('a', 'b', '__Decimal', params) }
64 | obj.b(num, 0.2, __Decimal))
65 | `, () => {
66 | expect(transformedCode).toMatch(`const obj = { b: new Function('a', 'b', '__Decimal', params) }`)
67 | expect(transformedCode).toMatch(`obj.b(num, 0.2, __Decimal))`)
68 | })
69 | it(`
70 | new Function Call Function
71 | input:
72 | const callFn = fn(num, 0.2)
73 | output:
74 | const callFn = fn(num, 0.2, __Decimal)
75 | `, () => {
76 | expect(transformedCode).toMatch(`const callFn = fn(num, 0.2, __Decimal)`)
77 | })
78 | }
79 | })
80 |
--------------------------------------------------------------------------------
/src/core/traverse/comment.ts:
--------------------------------------------------------------------------------
1 | import type { NodePath } from '@babel/traverse'
2 | import type { Comment } from '@babel/types'
3 | import { isJSXElement, isJSXEmptyExpression, isJSXExpressionContainer, isJSXOpeningElement } from '@babel/types'
4 | import { BASE_COMMENT, BLOCK_COMMENT, NEXT_COMMENT } from '../constant'
5 |
6 | export function getComments(path: NodePath) {
7 | const leadingComments = path.node.leadingComments ?? []
8 | const trailingComments = path.node.trailingComments ?? []
9 | const currentLineComments = trailingComments.filter((comment) => {
10 | return comment.loc?.start.line === path.node.loc?.start.line && comment.value.includes(BASE_COMMENT)
11 | })
12 | return [...leadingComments, ...currentLineComments]
13 | }
14 | export function blockComment(path: NodePath) {
15 | skipAutoDecimalComment(path, BLOCK_COMMENT)
16 | }
17 | export function nextComment(path: NodePath) {
18 | skipAutoDecimalComment(path, NEXT_COMMENT)
19 | }
20 | export function innerComment(path: NodePath, igc: string | string[] = [NEXT_COMMENT, BLOCK_COMMENT]) {
21 | skipAutoDecimalComment(path, igc, true)
22 | }
23 | function skipAutoDecimalComment(path: NodePath, igc: string | string[], isJSX = false) {
24 | let comments: Comment[] | undefined
25 | let startLine = -1
26 | const rawPath = path
27 | if (isJSX) {
28 | if (isJSXOpeningElement(path.node)) {
29 | path = path.parentPath!
30 | startLine = path.node.loc?.start.line ?? -1
31 | }
32 | else if (isJSXExpressionContainer(path.node)) {
33 | startLine = path.node.expression.loc?.start.line ?? -1
34 | }
35 | let prevPath = path.getPrevSibling()
36 | if (!prevPath.node)
37 | return
38 | while ((!isJSXExpressionContainer(prevPath.node) || !isJSXEmptyExpression(prevPath.node.expression)) || startLine !== -1) {
39 | if (startLine !== -1 && isJSXExpressionContainer(prevPath.node)) {
40 | if (isJSXEmptyExpression(prevPath.node.expression))
41 | break
42 | const exprStartLine = prevPath.node.loc?.start.line ?? 0
43 | if (exprStartLine !== startLine) {
44 | startLine = 0
45 | break
46 | }
47 | }
48 | prevPath = prevPath.getPrevSibling()
49 | if (!prevPath.node || isJSXElement(prevPath.node)) {
50 | if (isJSXElement(prevPath.node)) {
51 | const jsxElementStartLine = prevPath.node.loc?.start.line ?? 0
52 | if (startLine === jsxElementStartLine) {
53 | continue
54 | }
55 | }
56 | return
57 | }
58 | }
59 | if (!isJSXExpressionContainer(prevPath.node))
60 | return
61 | const { expression } = prevPath.node
62 | if (isJSXEmptyExpression(expression)) {
63 | comments = expression.innerComments ?? []
64 | }
65 | }
66 | else {
67 | comments = getComments(path)
68 | }
69 |
70 | const ignoreComment = Array.isArray(igc) ? igc : [igc]
71 | if (!comments)
72 | return
73 | const isIgnore = comments.some(comment => ignoreComment.some(ig => comment.value.includes(ig))) ?? false
74 | if (isIgnore) {
75 | rawPath.skip()
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/test/new-function-inject-window.test.ts:
--------------------------------------------------------------------------------
1 | import { promises as fs } from 'node:fs'
2 | import { resolve } from 'node:path'
3 | import fastGlob from 'fast-glob'
4 | import { describe, expect, it } from 'vitest'
5 | import { transform } from '../src/core/unplugin'
6 |
7 | describe('transform', async () => {
8 | const root = resolve(__dirname, 'fixtures')
9 | const files = await fastGlob('*-inject-window.ts', {
10 | cwd: root,
11 | onlyFiles: true,
12 | })
13 | for (const file of files) {
14 | const fixture = await fs.readFile(resolve(root, file), 'utf-8')
15 | const transformedCode = transform(fixture, file, {
16 | supportString: true,
17 | tailPatchZero: false,
18 | package: 'decimal.js-light',
19 | toDecimal: false,
20 | dts: false,
21 | decimalName: '__Decimal',
22 | supportNewFunction: {
23 | injectWindow: '$Dm',
24 | },
25 | })?.code ?? fixture
26 | it(`
27 | new Function return value
28 | input:
29 | const fn = new Function('a', 'b', \`return a + b\`)
30 | const result = fn(0.1, 0.2)
31 | output:
32 | const fn = new Function('a', 'b', \`return new window.$Dm(a).plus(b).toNumber()\`)
33 | const result = fn(0.1, 0.2)
34 | `, () => {
35 | expect(transformedCode).toMatch(`const fn = new Function('a', 'b', \`return new window.$Dm(a).plus(b).toNumber()\`)`)
36 | expect(transformedCode).toMatch(`const result = fn(0.1, 0.2)`)
37 | })
38 | it(`
39 | new Function params
40 | input:
41 | const result = fn(0.1, 0.2)
42 | output:
43 | const result = fn(0.1, 0.2)
44 | `, () => {
45 | expect(transformedCode).toMatch('const result = fn(0.1, 0.2)')
46 | })
47 | it(`
48 | new Function Array
49 | input:
50 | const arr = [1, new Function('a', 'b', params)]
51 | arr[1](0.1, 0.2)
52 | output:
53 | const arr = [1, new Function('a', 'b', params)]
54 | arr[1](0.1, 0.2)
55 | `, () => {
56 | expect(transformedCode).toMatch(`const arr = [1, new Function('a', 'b', params)]`)
57 | expect(transformedCode).toMatch(`arr[1](0.1, 0.2)`)
58 | })
59 | it(`
60 | new Function Object
61 | input:
62 | const obj = { b: new Function('a', 'b', params) }
63 | obj.b(num, 0.2))
64 | output:
65 | const obj = { b: new Function('a', 'b', params) }
66 | obj.b(num, 0.2))
67 | `, () => {
68 | expect(transformedCode).toMatch(`const obj = { b: new Function('a', 'b', params) }`)
69 | expect(transformedCode).toMatch(`obj.b(num, 0.2))`)
70 | })
71 | it(`
72 | new Function Call Function
73 | input:
74 | const callFn = fn(num, 0.2)
75 | output:
76 | const callFn = fn(num, 0.2)
77 | `, () => {
78 | expect(transformedCode).toMatch(`const callFn = fn(num, 0.2)`)
79 | })
80 | it(`
81 | new Function Call Function Inject Window
82 | input:
83 | return a + b + 3
84 | output:
85 | return new window.$Dm(a).plus(b).plus(3).toNumber()
86 | `, () => {
87 | expect(transformedCode).toMatch(`return new window.$Dm(a).plus(b).plus(3).toNumber()`)
88 | })
89 | }
90 | })
91 |
--------------------------------------------------------------------------------
/src/core/traverse/call-expression.ts:
--------------------------------------------------------------------------------
1 | import type { NodePath } from '@babel/traverse'
2 | import type { BinaryExpression, CallExpression, NewExpression } from '@babel/types'
3 | import type { InnerToDecimalOptions, Options } from '../../types'
4 | import { isBinaryExpression, isIdentifier, isMemberExpression, isObjectExpression } from '@babel/types'
5 | import { processBinary, resolveNewFunctionExpression } from '.'
6 | import { DEFAULT_TO_DECIMAL_CONFIG } from '../constant'
7 | import { mergeToDecimalOptions } from '../options'
8 | import { getRootBinaryExprPath, getRoundingMode } from '../utils'
9 |
10 | export function resolveCallExpression(path: NodePath, options: Options) {
11 | const { autoDecimalOptions } = options
12 | const { toDecimal, supportNewFunction } = autoDecimalOptions
13 | if (!toDecimal && !supportNewFunction)
14 | return
15 | const { node } = path
16 | const { callee, arguments: args } = node
17 | if (supportNewFunction && isIdentifier(callee) && callee.name === 'Function') {
18 | resolveNewFunctionExpression(path as unknown as NodePath, options)
19 | return
20 | }
21 | if (!isMemberExpression(callee))
22 | return
23 | const toDecimalOptions: InnerToDecimalOptions = { ...DEFAULT_TO_DECIMAL_CONFIG }
24 | if (toDecimal) {
25 | mergeToDecimalOptions(toDecimalOptions, toDecimal)
26 | }
27 | const { property, object } = callee
28 | if (!isIdentifier(property) || property.name !== toDecimalOptions.name)
29 | return
30 | if (!isBinaryExpression(path.parentPath.node) && !isBinaryExpression(object)) {
31 | throw new SyntaxError(`
32 | line: ${path.parentPath.node.loc?.start.line}, ${options.msa.sliceNode(path.parentPath.node).toString()} 或 ${options.msa.sliceNode(object).toString()} 不是有效的计算表达式
33 | `)
34 | }
35 | if (args && args.length > 0) {
36 | const [arg] = args
37 | if (!isObjectExpression(arg)) {
38 | throw new TypeError('toDecimal 参数错误')
39 | }
40 | const rawArg = options.msa.snipNode(arg).toString()
41 | const jsonArg = rawArg.replace(/(\w+):/g, '"$1":').replace(/'/g, '"')
42 | try {
43 | const argToDecimalOptions = JSON.parse(jsonArg)
44 | mergeToDecimalOptions(toDecimalOptions, argToDecimalOptions)
45 | }
46 | catch (e: unknown) {
47 | console.error(e)
48 | }
49 | }
50 | let callArgs = '()'
51 | if (toDecimalOptions.callMethod === 'toFixed') {
52 | callArgs = `(${toDecimalOptions.precision}, ${getRoundingMode(toDecimalOptions.roundingModes, autoDecimalOptions.package)})`
53 | }
54 | const start = object.end ?? 0
55 | options.msa.remove(start, node.end ?? 0)
56 | const resolveBinaryOptions = {
57 | ...options,
58 | initial: true,
59 | callArgs,
60 | callMethod: toDecimalOptions.callMethod,
61 | }
62 | if (isBinaryExpression(object)) {
63 | if (object.start !== node.start) {
64 | options.msa.remove(node.start ?? 0, object.start ?? 0)
65 | }
66 | object.extra = {
67 | ...object.extra,
68 | __extra: object.extra,
69 | options: resolveBinaryOptions,
70 | __shouldTransform: true,
71 | }
72 | return
73 | }
74 | const rootPath = getRootBinaryExprPath(path)
75 | const runtimeOptions = {} as Options
76 | processBinary(Object.assign(runtimeOptions, resolveBinaryOptions), rootPath as NodePath)
77 | Object.assign(options, { needImport: runtimeOptions.needImport })
78 | }
79 |
--------------------------------------------------------------------------------
/docs/guide/api/new-function.md:
--------------------------------------------------------------------------------
1 | # 支持 new Function ^(1.4.0)
2 |
3 | 默认情况下，`AutoDecimal` 仅会处理计算表达式，当启用了 `supportString` 属性时，也仅仅会处理计算表达式中可以被转换为数字的字符串。
4 |
5 | ```ts
6 | // AutoDecimal 默认参数下
7 | const a = 0.1
8 | const c = a + '0.2'
9 | console.log(c) // "0.10.2"
10 | ```
11 |
12 | 当 `supportString` 为 true 时
13 | ```ts
14 | const a = 0.1
15 | // 当启用 `supportString` 后，由于 '0.2' 可以被转换为数字，所以计算结果为 0.3
16 | const c = a + '0.2'
17 | console.log(c) // 0.3
18 | // 由于 'b' 不能转换为数字，所以结果为 '0.1b'
19 | const d = a + 'b'
20 | console.log(d) // '0.1b'
21 | ```
22 |
23 | 但是下面的却不会进行转换
24 | ```ts
25 | const fn = new Function('a', 'b', 'return a + b')
26 | const result = fn(0.1, 0.2)
27 | console.log(result) // 0.30000000000000004
28 | ```
29 | 因为 `fn` 是通过 `new Function` 创建的函数，而需要转换的 `return a + b`，是一个字符串，且 `AutoDecimal` 仅处理计算表达式，不会处理单个字符串。所以 `new Function` 中的字符串，会跳过。
30 |
31 | 那么如果想要 `AutoDecimal` 能够处理 `new Function` 中的字符串时，要怎么办呢。
32 |
33 |
34 | ## 配置项
35 | | 属性 | 描述 | 类型 | 默认值 |
36 | | :----------------: | :-------------------: | :------: |:------: |
37 | | toDecimal | 默认继承 [`toDecimal`](./to-decimal.md) 参数，如果设置此参数，则优先使用此参数 | ToDecimalConfig | - |
38 | | injectWindow ^(1.4.3) | 将 `Decimal` 挂载到 `window` 中的属性名称 | string | - |
39 |
40 |
41 | ## supportNewFunction
42 | :::code-group
43 | ```ts [vite.config.ts] {10}
44 | export default defineConfig({
45 | plugins: [
46 | AutoDecimal({
47 | /**
48 | * supportNewFunction: {
49 | * toDecimal?: boolean
50 | * injectWindow?: string
51 | * }
52 | */
53 | supportNewFunction: true
54 | })
55 | ]
56 | })
57 | ```
58 | :::
59 |
60 | 此时， `AutoDecimal` 就会解析 `new Function` 中的 'return a + b' 了。
61 |
62 | ```ts
63 | const fn = new Function('a', 'b', 'return a + b')
64 | const result = fn(0.1, 0.2)
65 | console.log(result) // 0.3
66 | ```
67 |
68 | ### supportNewFunction.toDecimal
69 | 此属性可以告诉 `AutoDecimal` 在处理 `new Function` 时，是否需要跟随 [`toDecimal`](./to-decimal.md)的设定来进行处理。
70 | 当启用了 `toDecimal` 后，可以通过 `supportNewFunction.toDecimal` 来单独启用、停用或者修改 `toDecimal` 的设定。
71 |
72 | :::code-group
73 | ```ts [vite.config.ts] {5}
74 | export default defineConfig({
75 | plugins: [
76 | AutoDecimal({
77 | toDecimal: true,
78 | supportNewFunction: {
79 | // 当这里设为 false 时，new Function 中的参数将不需要使用 toDecimal()
80 | toDecimal: false
81 | }
82 | })
83 | ]
84 | })
85 | ```
86 | :::
87 |
88 |
89 | :::tip
90 | 目前 `new Function` 支持的调用方式有限（目前所能想到的一些调用方式都已实现），它可以赋值给一个对象属性、数组中的某项、某个变量，但是一定不要太过于复杂，如果你遇到因为某些特殊的调用方式而造成的无法解析，或者无法得到正确的结果时，可以提[issues](https://github.com/lyumg/unplugin-auto-decimal/issues)，我会第一时间解决。
91 | :::
92 |
93 | ### supportNewFunction.injectWindow
94 | 由于在转换 `new Function` 时，`Decimal` 是通过参数注入的方式实现，需要查找 `new Function` 的定义、调用以及作用域等相关信息，费时费力。那么如果想 “肆意妄为” 的在 `new Function` 中使用 `Decimal`，要怎么办呢？可以先将 `decimal.js` 挂载到 `window` 上，然后通过 `injectWindow` 提供挂载的属性名称即可。
95 |
96 | 不使用 `injectWindow` 时，通过参数注入 `Decimal`
97 | ```ts {7,8}
98 | const fn = new Function('a', 'b', 'return a + b')
99 | const result = fn(0.1, 0.2)
100 | console.log(result) // 0.3
101 |
102 | // 上述代码会转换为
103 | import Decimal from 'decimal.js'
104 | const fn = new Function('a', 'b', 'Decimal', 'return new Decimal(a).plus(b).toNumber()')
105 | const result = fn(0.1, 0.2, Decimal)
106 | console.log(result) // 0.3
107 | ```
108 |
109 | 使用 `injectWindow` 时，直接使用 `window[injectWindow]` 来调用 `Decimal`
110 | :::code-group
111 | ```ts [vite.config.ts] {5}
112 | export default defineConfig({
113 | plugins: [
114 | AutoDecimal({
115 | supportNewFunction: {
116 | injectWindow: 'injectDecimal'
117 | }
118 | })
119 | ]
120 | })
121 | ```
122 | :::
123 |
124 | ```ts {6}
125 | const fn = new Function('a', 'b', 'return a + b')
126 | const result = fn(0.1, 0.2)
127 | console.log(result) // 0.3
128 |
129 | // 此时，上述代码会转换为
130 | const fn = new Function('a', 'b', 'return new window.injectDecimal(a).plus(b).toNumber()')
131 | const result = fn(0.1, 0.2)
132 | console.log(result) // 0.3
133 | ```
134 |
--------------------------------------------------------------------------------
/test/setup.test.ts:
--------------------------------------------------------------------------------
1 | import { promises as fs } from 'node:fs'
2 | import { resolve } from 'node:path'
3 | import fastGlob from 'fast-glob'
4 | import { describe, expect, it } from 'vitest'
5 | import { transform } from '../src/core/unplugin'
6 |
7 | describe('transform', async () => {
8 | const root = resolve(__dirname, 'fixtures')
9 | const files = await fastGlob('*setup.vue', {
10 | cwd: root,
11 | onlyFiles: true,
12 | })
13 | for (const file of files) {
14 | const fixture = await fs.readFile(resolve(root, file), 'utf-8')
15 | const transformedCode = transform(fixture, file, {
16 | supportString: true,
17 | tailPatchZero: false,
18 | package: 'decimal.js-light',
19 | toDecimal: false,
20 | dts: false,
21 | decimalName: '__Decimal',
22 | supportNewFunction: false,
23 | })?.code ?? fixture
24 |
25 | it(`
26 | vue.setup
27 | input:
28 | const sum = ref(0.1 + 0.2)
29 | output:
30 | const sum = ref(new __Decimal(0.1).plus(0.2).toNumber())
31 | `, () => {
32 | expect(transformedCode).toMatch('sum = ref(new __Decimal(0.1).plus(0.2).toNumber())')
33 | })
34 | it(`
35 | vue.setup next-ad-ignore
36 | input:
37 | const obj = {
38 | // next-ad-ignore
39 | a: 0.1 + 0.2,
40 | }
41 | output:
42 | const obj = {
43 | // next-ad-ignore
44 | a: 0.1 + 0.2,
45 | }
46 | `, () => {
47 | expect(transformedCode).toMatch('a: 0.1 + 0.2')
48 | })
49 | it(`
50 | vue.setup block-ad-ignore
51 | input:
52 | // block-ad-ignore
53 | function _test() {
54 | return 0.1 + 0.2
55 | }
56 | output:
57 | // block-ad-ignore
58 | function _test() {
59 | return 0.1 + 0.2
60 | }
61 | `, () => {
62 | expect(transformedCode).toMatch('return 0.1 + 0.2')
63 | })
64 | it(`
65 | vue.setup template
66 | input:
67 | transformed:{{ obj.a }} {{ 0.1 + 0.2 }}
68 | output:
69 | transformed:{{ obj.a }} {{ new __Decimal(0.1).plus(0.2).toNumber() }}
70 | `, () => {
71 | expect(transformedCode).toMatch('transformed:{{ obj.a }} {{ new __Decimal(0.1).plus(0.2).toNumber() }}
')
72 | })
73 | it(`
74 | vue.setup template next-ad-ignore
75 | input:
76 |
77 | next-ad-ignore:{{ 0.1 + 0.2 }}
78 | output:
79 |
80 | next-ad-ignore:{{ 0.1 + 0.2 }}
81 | `, () => {
82 | expect(transformedCode).toMatch('next-ad-ignore:{{ 0.1 + 0.2 }}')
83 | })
84 | it(`
85 | vue.setup template next-ad-ignore
86 | input:
87 |
88 |
89 | {{ 0.1 + 0.2 }}
90 |
91 | output:
92 |
93 |
94 | next-ad-ignore transform: {{ new __Decimal(0.1).plus(0.2).toNumber() }}
95 |
96 | `, () => {
97 | expect(transformedCode).toMatch('next-ad-ignore:{{ 0.1 + 0.2 }}')
98 | expect(transformedCode).toMatch('next-ad-ignore transform: {{ new __Decimal(0.1).plus(0.2).toNumber() }}')
99 | })
100 | it(`
101 | vue.setup template next-ad-ignore multiple
102 | input:
103 |
104 | next-ad-ignore multiple:{{ 0.1 + 0.2 }} {{ 1 - 0.9 }}
105 | output:
106 |
107 | next-ad-ignore multiple:{{ 0.1 + 0.2 }} {{ 1 - 0.9 }}
108 | `, () => {
109 | expect(transformedCode).toMatch('next-ad-ignore multiple:{{ 0.1 + 0.2 }} {{ 1 - 0.9 }}')
110 | })
111 | it(`
112 | vue.setup template next-ad-ignore multiple
113 | input:
114 |
115 | next-ad-ignore skip:{{ 0.1 + 0.2 }}
116 | next-ad-ignore transform: {{ 1 - 0.9 }}
117 | output:
118 |
119 | next-ad-ignore multiple skip:{{ 0.1 + 0.2 }}
120 | next-ad-ignore multiple transform: {{ new __Decimal(1).minus(0.9).toNumber() }}
121 | `, () => {
122 | expect(transformedCode).toMatch('next-ad-ignore multiple skip:{{ 0.1 + 0.2 }}')
123 | expect(transformedCode).toMatch('next-ad-ignore multiple transform: {{ new __Decimal(1).minus(0.9).toNumber() }}')
124 | })
125 | it(`
126 | vue.setup template block-ad-ignore
127 | input:
128 |
129 |
130 | block-ad-ignore:{{ 11.2 + 24.4 + 66 / (0.1 + 0.2) }}
131 |
132 | output:
133 |
134 |
135 | block-ad-ignore:{{ 11.2 + 24.4 + 66 / (0.1 + 0.2) }}
136 |
137 | `, () => {
138 | expect(transformedCode).toMatch('block-ad-ignore:{{ 11.2 + 24.4 + 66 / (0.1 + 0.2) }}')
139 | })
140 | }
141 | })
142 |
--------------------------------------------------------------------------------
/test/options.test.ts:
--------------------------------------------------------------------------------
1 | import { promises as fs } from 'node:fs'
2 | import { resolve } from 'node:path'
3 | import fastGlob from 'fast-glob'
4 | import { describe, expect, it } from 'vitest'
5 | import { transform } from '../src/core/unplugin'
6 |
7 | describe('transform', async () => {
8 | const root = resolve(__dirname, 'fixtures')
9 | const files = await fastGlob('*options.vue', {
10 | cwd: root,
11 | onlyFiles: true,
12 | })
13 | for (const file of files) {
14 | const fixture = await fs.readFile(resolve(root, file), 'utf-8')
15 | const transformedCode = transform(fixture, file, {
16 | supportString: true,
17 | tailPatchZero: false,
18 | package: 'decimal.js-light',
19 | toDecimal: false,
20 | dts: false,
21 | decimalName: '__Decimal',
22 | supportNewFunction: false,
23 | })?.code ?? fixture
24 | it(`
25 | vue
26 | input:
27 | const _s = \`\${0.1 + 0.2}\`
28 | output:
29 | const _s = \`\${new __Decimal(0.1).plus(0.2).toNumber()}\`
30 | `, () => {
31 | // eslint-disable-next-line no-template-curly-in-string
32 | expect(transformedCode).toMatch('const _s = `${new __Decimal(0.1).plus(0.2).toNumber()}`')
33 | })
34 | it(`
35 | vue next-ad-ignore
36 | input:
37 | // next-ad-ignore
38 | const _sum = 0.1 + 0.2
39 | output:
40 | // next-ad-ignore
41 | const _sum = 0.1 + 0.2
42 | `, () => {
43 | expect(transformedCode).toMatch('const _sum = 0.1 + 0.2')
44 | })
45 | it(`
46 | vue block-ad-ignore
47 | input:
48 | // block-ad-ignore
49 | {
50 | const _a = 0.1 + 0.2
51 | const _obj = { a: 0.1 + 0.2 }
52 | }
53 | output:
54 | // block-ad-ignore
55 | {
56 | const _a = 0.1 + 0.2
57 | const _obj = { a: 0.1 + 0.2 }
58 | }
59 | `, () => {
60 | expect(transformedCode).toMatch('const _a = 0.1 + 0.2')
61 | expect(transformedCode).toMatch('const _obj = { a: 0.1 + 0.2 }')
62 | })
63 | it(`
64 | vue template
65 | input:
66 |
67 | transform:{{ 0.1 + 0.2 }} b:{{ 1 - 0.9 }}
68 |
69 | output:
70 |
71 | transform:{{ new __Decimal(0.1).plus(0.2).toNumber() }} b:{{ new __Decimal(1).minus(0.9).toNumber() }}
72 |
73 | `, () => {
74 | expect(transformedCode).toMatch('')
75 | expect(transformedCode).toMatch('transform:{{ new __Decimal(0.1).plus(0.2).toNumber() }} b:{{ new __Decimal(1).minus(0.9).toNumber() }}')
76 | })
77 | it(`
78 | vue template next-ad-ignore
79 | input:
80 |
81 | next-ad-ignore transform:{{ 0.1 + 0.2 }}
82 |
83 | output:
84 |
85 | next-ad-ignore transform:{{ new __Decimal(0.1).plus(0.2).toNumber() }}
86 |
87 | `, () => {
88 | expect(transformedCode).toMatch('
')
89 | expect(transformedCode).toMatch('next-ad-ignore transform:{{ new __Decimal(0.1).plus(0.2).toNumber() }}')
90 | })
91 | it(`
92 | vue template next-ad-ignore
93 | input:
94 |
95 |
96 | next-ad-ignore :{{ 0.1 + 0.2 }}
97 |
98 | output:
99 |
100 |
101 | next-ad-ignore :{{ 0.1 + 0.2 }}
102 |
103 | `, () => {
104 | expect(transformedCode).toMatch('')
105 | expect(transformedCode).toMatch('next-ad-ignore:{{ 0.1 + 0.2 }}')
106 | })
107 | it(`
108 | vue template next-ad-ignore multiple skip:{{ 0.1 + 0.2 }} {{ 0.2 + 0.1 }}
109 | input:
110 |
111 | multiple skip:{{ 0.1 + 0.2 }} {{ 0.2 + 0.1 }}
112 | multiple transform:{{ 1 - 0.9 }}
113 | output:
114 |
115 | multiple skip:{{ 0.1 + 0.2 }} {{ 0.2 + 0.1 }}
116 | multiple transform:{{ new __Decimal(1).minus(0.9).toNumber() }}
117 | `, () => {
118 | expect(transformedCode).toMatch('multiple skip:{{ 0.1 + 0.2 }} {{ 0.2 + 0.1 }}')
119 | expect(transformedCode).toMatch('multiple transform:{{ new __Decimal(1).minus(0.9).toNumber() }}')
120 | })
121 | it(`
122 | vue template block-ad-ignore
123 | input:
124 |
125 |
126 | block-ad-ignore:{{ 0.1 + 0.2 }}
127 |
128 | output:
129 |
130 |
131 | block-ad-ignore:{{ 0.1 + 0.2 }}
132 |
133 | `, () => {
134 | expect(transformedCode).toMatch('')
135 | expect(transformedCode).toMatch('block-ad-ignore:{{ 0.1 + 0.2 }}')
136 | })
137 | }
138 | })
139 |
--------------------------------------------------------------------------------
/docs/guide/comment/ad-ignore.md:
--------------------------------------------------------------------------------
1 | # 添加相应注释
2 | 有时候，有些计算其实是不需要转换的。那么要如何跳过某个计算表达式或者都跳过呢？
3 |
4 | - 添加相应的注释（`jsx` 中需要注意, 在表达式中某些情况可能需要使用 JavaScript 注释）
5 | - 添加 `ad-ignore` prop
6 | - `supportString: true`时, 末尾拼接一个空字符串
7 | - `supportString: false`时, 末尾拼接任意字符串
8 |
9 | ## script
10 |
11 | 当你想跳过某个计算表达式，不需要转换时，可以使用 `next-ad-ignore`:
12 |
13 | ```ts
14 | // next-ad-ignore
15 | const igSum = 0.1 + 0.2;
16 | console.log('igSum => ', igSum); // 0.30000000000000004
17 |
18 | // 注释在右侧
19 | const igSumStrDirection = 0.1 + 0.2 // next-ad-ignore
20 | console.log('igSumStrDirection => ', igSumStrDirection); // '0.30000000000000004'
21 |
22 | // 末尾拼接一个空字符串
23 | const igSumStr = 0.1 + 0.2 + '';
24 | console.log('igSumStr => ', igSumStr); // '0.30000000000000004'
25 | ```
26 |
27 | 如果你想在某个作用域内，所有计算表达式都不进行转换的话，使用 `block-ad-ignore`:
28 |
29 | ```ts
30 | const sum = 0.1 + 0.2
31 | console.log('sum => ', sum) // 0.3
32 |
33 | const sumStr = 0.1 + 0.2 + ''
34 | console.log('sumStr => ', sumStr) // '0.30000000000000004'
35 | ...
36 | // block-ad-ignore
37 | {
38 | const igSum = 0.1 + 0.2
39 | console.log('igSum => ', igSum) // 0.30000000000000004
40 |
41 | const sum = 0.1 + 0.2
42 | console.log('sum => ', sum) // 0.30000000000000004
43 | }
44 |
45 | function sum() {
46 | const sum = 0.1 + 0.2
47 | console.log('sum => ', sum) // 0.3
48 |
49 | const sumStr = 0.1 + 0.2 + ''
50 | console.log('sum => ', sum) // '0.30000000000000004'
51 | }
52 | sum()
53 |
54 | // block-ad-ignore
55 | function igSumFn() {
56 | const igSum = 0.1 + 0.2
57 | console.log('sum => ', sum) // 0.30000000000000004
58 | }
59 | igSumFn()
60 | ```
61 |
62 | 如果某个文件内的计算表达式都不需要转换的话，可以在文件顶部使用 `file-ad-ignore`:
63 |
64 | ```ts
65 | // file-ad-ignore
66 | ...
67 | const igSum = 0.1 + 0.2
68 | console.log('igSum => ', igSum) // 0.30000000000000004
69 |
70 | const igSum2 = 0.1 + 0.2
71 | console.log('igSum2 => ', igSum2) // 0.30000000000000004
72 | ```
73 |
74 | ## vue template
75 |
76 | 如果想只禁用 `template` 内的计算表达式的话，在 `template` 标签添加 `ad-ignore` prop 即可。
77 |
78 | ```vue
79 |
80 |
81 | ...something
82 |
83 | ```
84 |
85 | `ad-ignore` 只影响在 `template` 中定义的计算表达式是否转换, 不会影响到 `script` 中定义的计算表达式。
86 | ```vue
87 |
88 |
89 |
95 |
96 |
99 | ```
100 |
101 | 在 `template` 中, 可以使用 `next-ad-ignore` 和 `block-ad-ignore`，也需要区分两种注释。
102 |
103 | - `next-ad-ignore` 用于组件 `prop` 和绑定的各个参数, 但不包含插槽与子集
104 | - `block-ad-ignore` 用于控制整个组件的所有属性包括插槽及子集
105 |
106 | ```html
107 |
108 |
109 |
110 |
111 |
112 |
113 | {{ 0.1 + 0.2 }}
114 |
115 |
116 |
117 |
118 |
119 |
{{ 0.1 + 0.2 }}
120 |
121 |
122 |
123 |
124 | {{ 0.1 + 0.2 }}
125 |
126 |
127 |
128 | {{ 0.1 + 0.2 }}
129 |
130 |
131 |
148 | {
149 | /*
150 | * next-ad-ignore
151 | * next-ad-ignore 不负责插槽和子集
152 | * 所以 title=0.30000000000000004
153 | * jsx comment: 0.3
154 | */
155 | }
156 |
jsx comment: {0.1 + 0.2}
157 |
158 | {/* 0.30000000000000004 */}
159 |
拼接空字符串: {0.1 + 0.2 + ''}
160 |
161 | {/* 0.3 */}
162 |
正常输出: {0.1 + 0.2}
163 | {
164 | /**
165 | * block-ad-ignore
166 | * 组件中所有的属性都不会转换
167 | * num=0.30000000000000004
168 | */
169 | }
170 |
171 | {/* slot 0.30000000000000004 */}
172 | {0.1 + 0.2}
173 | {/* num=0.30000000000000004 */}
174 |
175 | {/* slot 0.30000000000000004 */}
176 | {0.1 + 0.2}
177 |
178 |
179 | {
180 | list.map(item => {
181 | {/* 这里要注意使用 JavaScript 中的注释形式, 不能使用 jsx 中的注释形式 */}
182 | {/* 这里要注意使用 JavaScript 中的注释形式, 不能使用 jsx 中的注释形式 */}
183 | {/* 这里要注意使用 JavaScript 中的注释形式, 不能使用 jsx 中的注释形式 */}
184 |
185 | {/* 所以这种是不生效的 next-ad-ignore */}
186 | const sum = 0.1 + 0.2
187 | console.log('sum => ', sum) // 0.3
188 | // 这种是生效的 next-ad-ignore
0.30000000000000004
189 | return
{item + 0.2}
190 | })
191 | }
192 |
5 |
6 | 
3 |