wip(compiler-ssr): v-model static types + textarea

diff --git a/packages/compiler-core/src/ast.ts b/packages/compiler-core/src/ast.ts
index 97d64b20392da2408acb13d44e0bab4cb2a19d83..cd605832e1f5a4d7a996abea97fe49dd923f19de 100644 (file)
--- a/packages/compiler-core/src/ast.ts
+++ b/packages/compiler-core/src/ast.ts
@@ -204,6 +204,7 @@ export interface CompoundExpressionNode extends Node {
   type: NodeTypes.COMPOUND_EXPRESSION
   children: (
     | SimpleExpressionNode
+    | CompoundExpressionNode
     | InterpolationNode
     | TextNode
     | string

diff --git a/packages/compiler-core/src/transforms/vModel.ts b/packages/compiler-core/src/transforms/vModel.ts
index 8e13cc10a3976540c1cebb382cddc8cf6dd9df1e..7211334c3d070a0fcfd609b83754cbebcd1c0546 100644 (file)
--- a/packages/compiler-core/src/transforms/vModel.ts
+++ b/packages/compiler-core/src/transforms/vModel.ts
@@ -56,11 +56,7 @@ export const transformModel: DirectiveTransform = (dir, node, context) => {
     // "onUpdate:modelValue": $event => (foo = $event)
     createObjectProperty(
       eventName,
-      createCompoundExpression([
-        `$event => (`,
-        ...(exp.type === NodeTypes.SIMPLE_EXPRESSION ? [exp] : exp.children),
-        ` = $event)`
-      ])
+      createCompoundExpression([`$event => (`, exp, ` = $event)`])
     )
   ]
 
@@ -82,12 +78,7 @@ export const transformModel: DirectiveTransform = (dir, node, context) => {
     const modifiersKey = arg
       ? arg.type === NodeTypes.SIMPLE_EXPRESSION && arg.isStatic
         ? `${arg.content}Modifiers`
-        : createCompoundExpression([
-            ...(arg.type === NodeTypes.SIMPLE_EXPRESSION
-              ? [arg]
-              : arg.children),
-            ' + "Modifiers"'
-          ])
+        : createCompoundExpression([arg, ' + "Modifiers"'])
       : `modelModifiers`
     props.push(
       createObjectProperty(

diff --git a/packages/compiler-core/src/transforms/vOn.ts b/packages/compiler-core/src/transforms/vOn.ts
index d6ecd14587e510f3b0bad6c74adb6249b338ddc8..c56b300c01039fb5d10dddbc3ea3e091390fca46 100644 (file)
--- a/packages/compiler-core/src/transforms/vOn.ts
+++ b/packages/compiler-core/src/transforms/vOn.ts
@@ -87,7 +87,7 @@ export const transformOn: DirectiveTransform = (
       // wrap inline statement in a function expression
       exp = createCompoundExpression([
         `$event => ${hasMultipleStatements ? `{` : `(`}`,
-        ...(exp.type === NodeTypes.SIMPLE_EXPRESSION ? [exp] : exp.children),
+        exp,
         hasMultipleStatements ? `}` : `)`
       ])
     }

diff --git a/packages/compiler-dom/src/errors.ts b/packages/compiler-dom/src/errors.ts
index 87579a8cdbd88e28ae597fafde82371b3784f637..8ead25260424d05a652972cfb1c7feec55975169 100644 (file)
--- a/packages/compiler-dom/src/errors.ts
+++ b/packages/compiler-dom/src/errors.ts
@@ -28,6 +28,7 @@ export const enum DOMErrorCodes {
   X_V_MODEL_ON_INVALID_ELEMENT,
   X_V_MODEL_ARG_ON_ELEMENT,
   X_V_MODEL_ON_FILE_INPUT_ELEMENT,
+  X_V_MODEL_UNNECESSARY_VALUE,
   X_V_SHOW_NO_EXPRESSION,
   __EXTEND_POINT__
 }
@@ -40,5 +41,6 @@ export const DOMErrorMessages: { [code: number]: string } = {
   [DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
   [DOMErrorCodes.X_V_MODEL_ARG_ON_ELEMENT]: `v-model argument is not supported on plain elements.`,
   [DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT]: `v-model cannot used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+  [DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
   [DOMErrorCodes.X_V_SHOW_NO_EXPRESSION]: `v-show is missing expression.`
 }

diff --git a/packages/compiler-dom/src/index.ts b/packages/compiler-dom/src/index.ts
index 01673e847a8eb5090a61de025d52ea1aefc97ab9..6cecb8b2c91da08973016f2ca09f8f09b9116cac 100644 (file)
--- a/packages/compiler-dom/src/index.ts
+++ b/packages/compiler-dom/src/index.ts
@@ -57,5 +57,5 @@ export function parse(template: string, options: ParserOptions = {}): RootNode {
 }
 
 export { transformStyle } from './transforms/transformStyle'
-export { DOMErrorCodes } from './errors'
+export { createDOMCompilerError, DOMErrorCodes } from './errors'
 export * from '@vue/compiler-core'

diff --git a/packages/compiler-dom/src/transforms/vModel.ts b/packages/compiler-dom/src/transforms/vModel.ts
index 79d1b8aeae24fa12930217a801abb808f2ee87a8..83d623f50772b918c14417391fa36310f5da9885 100644 (file)
--- a/packages/compiler-dom/src/transforms/vModel.ts
+++ b/packages/compiler-dom/src/transforms/vModel.ts
@@ -16,68 +16,88 @@ import {
 
 export const transformModel: DirectiveTransform = (dir, node, context) => {
   const baseResult = baseTransform(dir, node, context)
-  // base transform has errors
-  if (!baseResult.props.length) {
+  // base transform has errors OR component v-model (only need props)
+  if (!baseResult.props.length || node.tagType === ElementTypes.COMPONENT) {
     return baseResult
   }
 
-  const { tag, tagType } = node
-  if (tagType === ElementTypes.ELEMENT) {
-    if (dir.arg) {
+  if (dir.arg) {
+    context.onError(
+      createDOMCompilerError(
+        DOMErrorCodes.X_V_MODEL_ARG_ON_ELEMENT,
+        dir.arg.loc
+      )
+    )
+  }
+
+  function checkDuplicatedValue() {
+    const value = findProp(node, 'value')
+    if (value) {
       context.onError(
         createDOMCompilerError(
-          DOMErrorCodes.X_V_MODEL_ARG_ON_ELEMENT,
-          dir.arg.loc
+          DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE,
+          value.loc
         )
       )
     }
+  }
 
-    if (tag === 'input' || tag === 'textarea' || tag === 'select') {
-      let directiveToUse = V_MODEL_TEXT
-      let isInvalidType = false
-      if (tag === 'input') {
-        const type = findProp(node, `type`)
-        if (type) {
-          if (type.type === NodeTypes.DIRECTIVE) {
-            // :type="foo"
-            directiveToUse = V_MODEL_DYNAMIC
-          } else if (type.value) {
-            switch (type.value.content) {
-              case 'radio':
-                directiveToUse = V_MODEL_RADIO
-                break
-              case 'checkbox':
-                directiveToUse = V_MODEL_CHECKBOX
-                break
-              case 'file':
-                isInvalidType = true
-                context.onError(
-                  createDOMCompilerError(
-                    DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT,
-                    dir.loc
-                  )
+  const { tag } = node
+  if (tag === 'input' || tag === 'textarea' || tag === 'select') {
+    let directiveToUse = V_MODEL_TEXT
+    let isInvalidType = false
+    if (tag === 'input') {
+      const type = findProp(node, `type`)
+      if (type) {
+        if (type.type === NodeTypes.DIRECTIVE) {
+          // :type="foo"
+          directiveToUse = V_MODEL_DYNAMIC
+        } else if (type.value) {
+          switch (type.value.content) {
+            case 'radio':
+              directiveToUse = V_MODEL_RADIO
+              break
+            case 'checkbox':
+              directiveToUse = V_MODEL_CHECKBOX
+              break
+            case 'file':
+              isInvalidType = true
+              context.onError(
+                createDOMCompilerError(
+                  DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT,
+                  dir.loc
                 )
-                break
-            }
+              )
+              break
+            default:
+              // text type
+              __DEV__ && checkDuplicatedValue()
+              break
           }
         }
-      } else if (tag === 'select') {
-        directiveToUse = V_MODEL_SELECT
-      }
-      // inject runtime directive
-      // by returning the helper symbol via needRuntime
-      // the import will replaced a resolveDirective call.
-      if (!isInvalidType) {
-        baseResult.needRuntime = context.helper(directiveToUse)
+      } else {
+        // text type
+        __DEV__ && checkDuplicatedValue()
       }
-    } else {
-      context.onError(
-        createDOMCompilerError(
-          DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT,
-          dir.loc
-        )
-      )
+    } else if (tag === 'select') {
+      directiveToUse = V_MODEL_SELECT
+    } else if (tag === 'textarea') {
+      __DEV__ && checkDuplicatedValue()
     }
+    // inject runtime directive
+    // by returning the helper symbol via needRuntime
+    // the import will replaced a resolveDirective call.
+    if (!isInvalidType) {
+      baseResult.needRuntime = context.helper(directiveToUse)
+    }
+  } else {
+    context.onError(
+      createDOMCompilerError(
+        DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT,
+        dir.loc
+      )
+    )
   }
+
   return baseResult
 }

diff --git a/packages/compiler-ssr/__tests__/ssrVModel.spec.ts b/packages/compiler-ssr/__tests__/ssrVModel.spec.ts
new file mode 100644 (file)
index 0000000..31ee50c
--- /dev/null
+++ b/packages/compiler-ssr/__tests__/ssrVModel.spec.ts
@@ -0,0 +1,68 @@
+import { compile } from '../src'
+
+describe('ssr: v-model', () => {
+  test('<input> (text types)', () => {
+    expect(compile(`<input v-model="bar">`).code).toMatchInlineSnapshot(`
+      "const { _renderAttr } = require(\\"@vue/server-renderer\\")
+
+      return function ssrRender(_ctx, _push, _parent) {
+        _push(\`<input\${_renderAttr(\\"value\\", _ctx.bar)}>\`)
+      }"
+    `)
+
+    expect(compile(`<input type="email" v-model="bar">`).code)
+      .toMatchInlineSnapshot(`
+      "const { _renderAttr } = require(\\"@vue/server-renderer\\")
+
+      return function ssrRender(_ctx, _push, _parent) {
+        _push(\`<input type=\\"email\\"\${_renderAttr(\\"value\\", _ctx.bar)}>\`)
+      }"
+    `)
+  })
+
+  test('<input type="radio">', () => {
+    expect(compile(`<input type="radio" value="foo" v-model="bar">`).code)
+      .toMatchInlineSnapshot(`
+      "const { _looseEqual } = require(\\"@vue/server-renderer\\")
+
+      return function ssrRender(_ctx, _push, _parent) {
+        _push(\`<input type=\\"radio\\" value=\\"foo\\"\${(_looseEqual(_ctx.bar, \\"foo\\")) ? \\" checked\\" : \\"\\"}>\`)
+      }"
+    `)
+  })
+
+  test('<input type="checkbox"', () => {
+    expect(compile(`<input type="checkbox" v-model="bar">`).code)
+      .toMatchInlineSnapshot(`
+      "const { _looseContain } = require(\\"@vue/server-renderer\\")
+
+      return function ssrRender(_ctx, _push, _parent) {
+        _push(\`<input type=\\"checkbox\\"\${((Array.isArray(_ctx.bar))
+          ? _looseContain(_ctx.bar, null)
+          : _ctx.bar) ? \\" checked\\" : \\"\\"}>\`)
+      }"
+    `)
+
+    expect(compile(`<input type="checkbox" value="foo" v-model="bar">`).code)
+      .toMatchInlineSnapshot(`
+      "const { _looseContain } = require(\\"@vue/server-renderer\\")
+
+      return function ssrRender(_ctx, _push, _parent) {
+        _push(\`<input type=\\"checkbox\\" value=\\"foo\\"\${((Array.isArray(_ctx.bar))
+          ? _looseContain(_ctx.bar, \\"foo\\")
+          : _ctx.bar) ? \\" checked\\" : \\"\\"}>\`)
+      }"
+    `)
+  })
+
+  test('<textarea>', () => {
+    expect(compile(`<textarea v-model="foo">bar</textarea>`).code)
+      .toMatchInlineSnapshot(`
+      "const { _interpolate } = require(\\"@vue/server-renderer\\")
+
+      return function ssrRender(_ctx, _push, _parent) {
+        _push(\`<textarea>\${_interpolate(_ctx.foo)}</textarea>\`)
+      }"
+    `)
+  })
+})

diff --git a/packages/compiler-ssr/src/runtimeHelpers.ts b/packages/compiler-ssr/src/runtimeHelpers.ts
index 392b0eadc7c91411f35ad2f00ce592c005606488..87fd6b35f17446db8c157d2f34b695ad0738ccc3 100644 (file)
--- a/packages/compiler-ssr/src/runtimeHelpers.ts
+++ b/packages/compiler-ssr/src/runtimeHelpers.ts
@@ -9,6 +9,8 @@ export const SSR_RENDER_ATTRS = Symbol(`renderAttrs`)
 export const SSR_RENDER_ATTR = Symbol(`renderAttr`)
 export const SSR_RENDER_DYNAMIC_ATTR = Symbol(`renderDynamicAttr`)
 export const SSR_RENDER_LIST = Symbol(`renderList`)
+export const SSR_LOOSE_EQUAL = Symbol(`looseEqual`)
+export const SSR_LOOSE_CONTAIN = Symbol(`looseContain`)
 
 export const ssrHelpers = {
   [SSR_INTERPOLATE]: `_interpolate`,
@@ -19,7 +21,9 @@ export const ssrHelpers = {
   [SSR_RENDER_ATTRS]: `_renderAttrs`,
   [SSR_RENDER_ATTR]: `_renderAttr`,
   [SSR_RENDER_DYNAMIC_ATTR]: `_renderDynamicAttr`,
-  [SSR_RENDER_LIST]: `_renderList`
+  [SSR_RENDER_LIST]: `_renderList`,
+  [SSR_LOOSE_EQUAL]: `_looseEqual`,
+  [SSR_LOOSE_CONTAIN]: `_looseContain`
 }
 
 // Note: these are helpers imported from @vue/server-renderer

diff --git a/packages/compiler-ssr/src/transforms/ssrVModel.ts b/packages/compiler-ssr/src/transforms/ssrVModel.ts
index 077991d830f3d598234d32da0cb9db829450a9e5..8d4c0ad6dfb8fd1c62ef3ed4f5e78929d73e4db4 100644 (file)
--- a/packages/compiler-ssr/src/transforms/ssrVModel.ts
+++ b/packages/compiler-ssr/src/transforms/ssrVModel.ts
@@ -1,7 +1,123 @@
-import { DirectiveTransform } from '@vue/compiler-dom'
+import {
+  DirectiveTransform,
+  ElementTypes,
+  transformModel,
+  findProp,
+  NodeTypes,
+  createDOMCompilerError,
+  DOMErrorCodes,
+  Property,
+  createObjectProperty,
+  createSimpleExpression,
+  createCallExpression,
+  PlainElementNode,
+  ExpressionNode,
+  createConditionalExpression,
+  createInterpolation
+} from '@vue/compiler-dom'
+import { SSR_LOOSE_EQUAL, SSR_LOOSE_CONTAIN } from '../runtimeHelpers'
 
 export const ssrTransformModel: DirectiveTransform = (dir, node, context) => {
-  return {
-    props: []
+  const model = dir.exp!
+
+  function checkDuplicatedValue() {
+    const value = findProp(node, 'value')
+    if (value) {
+      context.onError(
+        createDOMCompilerError(
+          DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE,
+          value.loc
+        )
+      )
+    }
+  }
+
+  if (node.tagType === ElementTypes.ELEMENT) {
+    let props: Property[] = []
+    const defaultProps = [
+      // default value binding for text type inputs
+      createObjectProperty(createSimpleExpression(`value`, true), model)
+    ]
+    if (node.tag === 'input') {
+      const type = findProp(node, 'type')
+      if (type) {
+        if (type.type === NodeTypes.DIRECTIVE) {
+          // dynamic type
+          // TODO
+        } else if (type.value) {
+          // static type
+          switch (type.value.content) {
+            case 'radio':
+              props = [
+                createObjectProperty(
+                  createSimpleExpression(`checked`, true),
+                  createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
+                    model,
+                    findValueBinding(node)
+                  ])
+                )
+              ]
+              break
+            case 'checkbox':
+              const value = findValueBinding(node)
+              props = [
+                createObjectProperty(
+                  createSimpleExpression(`checked`, true),
+                  createConditionalExpression(
+                    createCallExpression(`Array.isArray`, [model]),
+                    createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [
+                      model,
+                      value
+                    ]),
+                    model
+                  )
+                )
+              ]
+              break
+            case 'file':
+              context.onError(
+                createDOMCompilerError(
+                  DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT,
+                  dir.loc
+                )
+              )
+              break
+            default:
+              checkDuplicatedValue()
+              props = defaultProps
+              break
+          }
+        }
+      } else {
+        checkDuplicatedValue()
+        props = defaultProps
+      }
+    } else if (node.tag === 'textarea') {
+      checkDuplicatedValue()
+      node.children = [createInterpolation(model, model.loc)]
+    } else if (node.tag === 'select') {
+      // TODO
+    } else {
+      context.onError(
+        createDOMCompilerError(
+          DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT,
+          dir.loc
+        )
+      )
+    }
+
+    return { props }
+  } else {
+    // component v-model
+    return transformModel(dir, node, context)
   }
 }
+
+function findValueBinding(node: PlainElementNode): ExpressionNode {
+  const valueBinding = findProp(node, 'value')
+  return valueBinding
+    ? valueBinding.type === NodeTypes.DIRECTIVE
+      ? valueBinding.exp!
+      : createSimpleExpression(valueBinding.value!.content, true)
+    : createSimpleExpression(`null`, false)
+}

diff --git a/packages/compiler-ssr/src/transforms/ssrVShow.ts b/packages/compiler-ssr/src/transforms/ssrVShow.ts
index d46cac737c6fb131b5098de9c583f1518ba44e70..314d8a234c2da70088a6eb6bcf45cab685e87766 100644 (file)
--- a/packages/compiler-ssr/src/transforms/ssrVShow.ts
+++ b/packages/compiler-ssr/src/transforms/ssrVShow.ts
@@ -1,16 +1,18 @@
 import {
   DirectiveTransform,
-  createCompilerError,
   DOMErrorCodes,
   createObjectProperty,
   createSimpleExpression,
   createConditionalExpression,
-  createObjectExpression
+  createObjectExpression,
+  createDOMCompilerError
 } from '@vue/compiler-dom'
 
 export const ssrTransformShow: DirectiveTransform = (dir, node, context) => {
   if (!dir.exp) {
-    context.onError(createCompilerError(DOMErrorCodes.X_V_SHOW_NO_EXPRESSION))
+    context.onError(
+      createDOMCompilerError(DOMErrorCodes.X_V_SHOW_NO_EXPRESSION)
+    )
   }
   return {
     props: [

diff --git a/packages/runtime-dom/src/directives/vModel.ts b/packages/runtime-dom/src/directives/vModel.ts
index 8cc9ea7b8b3acce762b361b8a83717b724962a7d..8b1343944f40c71288e2a712fa757ea4dff7c405 100644 (file)
--- a/packages/runtime-dom/src/directives/vModel.ts
+++ b/packages/runtime-dom/src/directives/vModel.ts
@@ -5,7 +5,7 @@ import {
   warn
 } from '@vue/runtime-core'
 import { addEventListener } from '../modules/events'
-import { isArray, isObject } from '@vue/shared'
+import { isArray, looseEqual, looseIndexOf } from '@vue/shared'
 
 const getModelAssigner = (vnode: VNode): ((value: any) => void) =>
   vnode.props!['onUpdate:modelValue']
@@ -182,47 +182,6 @@ function setSelected(el: HTMLSelectElement, value: any) {
   }
 }
 
-function looseEqual(a: any, b: any): boolean {
-  if (a === b) return true
-  const isObjectA = isObject(a)
-  const isObjectB = isObject(b)
-  if (isObjectA && isObjectB) {
-    try {
-      const isArrayA = isArray(a)
-      const isArrayB = isArray(b)
-      if (isArrayA && isArrayB) {
-        return (
-          a.length === b.length &&
-          a.every((e: any, i: any) => looseEqual(e, b[i]))
-        )
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        const keysA = Object.keys(a)
-        const keysB = Object.keys(b)
-        return (
-          keysA.length === keysB.length &&
-          keysA.every(key => looseEqual(a[key], b[key]))
-        )
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
-    }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
-}
-
-function looseIndexOf(arr: any[], val: any): number {
-  return arr.findIndex(item => looseEqual(item, val))
-}
-
 // retrieve raw value set via :value bindings
 function getValue(el: HTMLOptionElement | HTMLInputElement) {
   return '_value' in el ? (el as any)._value : el.value

diff --git a/packages/server-renderer/src/index.ts b/packages/server-renderer/src/index.ts
index 39e5c3e33088f610f2ec1be9007ca5d2ea822e76..099a2e0348cf2e32664f7b71fb4c50c15219410b 100644 (file)
--- a/packages/server-renderer/src/index.ts
+++ b/packages/server-renderer/src/index.ts
@@ -15,3 +15,9 @@ export {
 } from './helpers/renderAttrs'
 export { interpolate as _interpolate } from './helpers/interpolate'
 export { renderList as _renderList } from './helpers/renderList'
+
+// v-model helpers
+import { looseEqual, looseIndexOf } from '@vue/shared'
+export const _looseEqual = looseEqual as (a: unknown, b: unknown) => boolean
+export const _looseContain = (arr: unknown[], value: unknown): boolean =>
+  looseIndexOf(arr, value) > -1

diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index 3a1c07f2d604a143b18bba7946a418899b05bb76..4ec5d8d91be3cce65ac2d8a69e1aca381fb57061 100644 (file)
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -9,6 +9,7 @@ export * from './normalizeProp'
 export * from './domTagConfig'
 export * from './domAttrConfig'
 export * from './escapeHtml'
+export * from './looseEqual'
 
 export const EMPTY_OBJ: { readonly [key: string]: any } = __DEV__
   ? Object.freeze({})

diff --git a/packages/shared/src/looseEqual.ts b/packages/shared/src/looseEqual.ts
new file mode 100644 (file)
index 0000000..bd58332
--- /dev/null
+++ b/packages/shared/src/looseEqual.ts
@@ -0,0 +1,42 @@
+import { isObject, isArray } from './'
+
+export function looseEqual(a: any, b: any): boolean {
+  if (a === b) return true
+  const isObjectA = isObject(a)
+  const isObjectB = isObject(b)
+  if (isObjectA && isObjectB) {
+    try {
+      const isArrayA = isArray(a)
+      const isArrayB = isArray(b)
+      if (isArrayA && isArrayB) {
+        return (
+          a.length === b.length &&
+          a.every((e: any, i: any) => looseEqual(e, b[i]))
+        )
+      } else if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime()
+      } else if (!isArrayA && !isArrayB) {
+        const keysA = Object.keys(a)
+        const keysB = Object.keys(b)
+        return (
+          keysA.length === keysB.length &&
+          keysA.every(key => looseEqual(a[key], b[key]))
+        )
+      } else {
+        /* istanbul ignore next */
+        return false
+      }
+    } catch (e) {
+      /* istanbul ignore next */
+      return false
+    }
+  } else if (!isObjectA && !isObjectB) {
+    return String(a) === String(b)
+  } else {
+    return false
+  }
+}
+
+export function looseIndexOf(arr: any[], val: any): number {
+  return arr.findIndex(item => looseEqual(item, val))
+}

diff --git a/packages/vue/src/index.ts b/packages/vue/src/index.ts
index f79b76960eaf2126956d78697a10df9f4ddb9fce..2cc408889a0deaff870e57fbd9c19a20c03332ad 100644 (file)
--- a/packages/vue/src/index.ts
+++ b/packages/vue/src/index.ts
@@ -47,6 +47,8 @@ function compileToFunction(
             err.loc.end.offset
           )
         warn(codeFrame ? `${message}\n${codeFrame}` : message)
+      } else {
+        throw err
       }
     },
     ...options