func main · vuejs/vue — 339 matches

.github/CONTRIBUTING.md MARKDOWN 5 matches view file →

- **`packages`**:
  - `vue-server-renderer` and `vue-template-compiler` are distributed as separate NPM packages. They are automatically generated from the source code and always have the same version with the main `vue` package.
  - `compiler-sfc` is an internal package that is distributed as part of the main `vue` package. It's aliased and can be imported as `vue/compiler-sfc` similar to Vue 3.

· · ·

  - `compiler-sfc` is an internal package that is distributed as part of the main `vue` package. It's aliased and can be imported as `vue/compiler-sfc` similar to Vue 3.
- **`test`**: contains all tests. The unit tests are written with [Jasmine](http://jasmine.github.io/2.3/introduction.html) and run with [Karma](http://karma-runner.github.io/0.13/index.html). The e2e tests are written for and run with [Nightwatch.js](http://nightwatchjs.org/).

· · ·

- **`src`**: contains the source code. The codebase is written in ES2015 with [Flow](https://flowtype.org/) type annotations.
  - **`compiler`**: contains code for the template-to-render-function compiler.
    The compiler consists of a parser (converts template strings to element ASTs), an optimizer (detects static trees for vdom render optimization), and a code generator (generate render function code from element ASTs). Note that codegen directly generates code strings from the element AST - it's done this way for smaller code size because the compiler is shipped to the browser in the standalone build.

· · ·

    The compiler consists of a parser (converts template strings to element ASTs), an optimizer (detects static trees for vdom render optimization), and a code generator (generate render function code from element ASTs). Note that codegen directly generates code strings from the element AST - it's done this way for smaller code size because the compiler is shipped to the browser in the standalone build.
  - **`core`**: contains universal, platform-agnostic runtime code.

· · ·

    Entry files for dist builds are located in their respective platform directory.
    Each platform module contains three parts: `compiler`, `runtime` and `server`, corresponding to the three directories above. Each part contains platform-specific modules/utilities which are imported and injected to the core counterparts in platform-specific entry files. For example, the code implementing the logic behind `v-bind:class` is in `platforms/web/runtime/modules/class.js` - which is imported in `platforms/web/entry-runtime.ts` and used to create the browser-specific vdom patching function.
  - **`sfc`**: contains single-file component (`*.vue` files) parsing logic. This is used in the `vue-template-compiler` package.

CHANGELOG.md MARKDOWN 35 matches · showing 5 view file →

* **sfc:** remove sfc scoped deep syntax deprecation warnings ([2f335b2](https://github.com/vuejs/vue/commit/2f335b2f9d09b962f40e38740826d444e4fff073))
* **types:** fix error with options watch ([#12779](https://github.com/vuejs/vue/issues/12779)) ([bc5b92a](https://github.com/vuejs/vue/commit/bc5b92adde147436f2adb25e457f0c967829467f)), closes [#12780](https://github.com/vuejs/vue/issues/12780)
* **types:** support Ref and function types in tsx ref attribute ([#12759](https://github.com/vuejs/vue/issues/12759)) ([87f69aa](https://github.com/vuejs/vue/commit/87f69aa26f195390b948fbb0ff62cf954b58c82c)), closes [#12758](https://github.com/vuejs/vue/issues/12758)
* **types:** vue 3 directive type compatibility ([#12792](https://github.com/vuejs/vue/issues/12792)) ([27eed82](https://github.com/vuejs/vue/commit/27eed829ccf9978a63b8cd989ff4c03897276bc2))

· · ·

* **build:** fix mjs dual package hazard ([012e10c](https://github.com/vuejs/vue/commit/012e10c9ca13fcbc9bf67bf2835883edcd4faace)), closes [#12626](https://github.com/vuejs/vue/issues/12626)
* **compiler-sfc:** use safer deindent default for compatibility with previous behavior ([b70a258](https://github.com/vuejs/vue/commit/b70a2585fcd102def2bb5a3b2b589edf5311122d))
* pass element creation helper to static render fns for functional components ([dc8a68e](https://github.com/vuejs/vue/commit/dc8a68e8c6c4e8ed4fdde094004fca272d71ef2e)), closes [#12625](https://github.com/vuejs/vue/issues/12625)
* **ssr/reactivity:** fix array setting error at created in ssr [[#12632](https://github.com/vuejs/vue/issues/12632)] ([#12633](https://github.com/vuejs/vue/issues/12633)) ([ca7daef](https://github.com/vuejs/vue/commit/ca7daefaa15a192046d22d060220cd595a6a275f))
* **types:** fix missing instance properties on defineComponent this ([f8de4ca](https://github.com/vuejs/vue/commit/f8de4ca9d458a03378e848b1e62d6507f7124871)), closes [#12628](https://github.com/vuejs/vue/issues/12628#issuecomment-1177258223)

· · ·

* defineAsyncComponent ([9d12106](https://github.com/vuejs/vue/commit/9d12106e211e0cbf33f9066606a8ff29f8cc8e8d)), closes [#12608](https://github.com/vuejs/vue/issues/12608)
* support functional components in defineComponent ([559600f](https://github.com/vuejs/vue/commit/559600f13d312915c0a1b54ed4edd41327dbedd6)), closes [#12619](https://github.com/vuejs/vue/issues/12619)

· · ·

- The `emits` option is also supported, but only for type-checking purposes (does not affect runtime behavior)
  2.7 also supports using ESNext syntax in template expressions. When using a build system, the compiled template render function will go through the same loaders / plugins configured for normal JavaScript. This means if you have configured Babel for `.js` files, it will also apply to the expressions in your SFC templates.
### Notes on API exposure

· · ·

- **compiler:** event handlers with modifiers swallowing arguments (fix [#10867](https://github.com/vuejs/vue/issues/10867)) ([#10958](https://github.com/vuejs/vue/issues/10958)) ([8620706](https://github.com/vuejs/vue/commit/862070662dd4871cb834664435ec836df57c7d57))
- **core:** fix sameVnode for async component ([#11107](https://github.com/vuejs/vue/issues/11107)) ([5260830](https://github.com/vuejs/vue/commit/52608302e9bca84fb9e9f0499e89acade78d3d07))
- **core:** remove trailing comma in function signature ([#10845](https://github.com/vuejs/vue/issues/10845)) ([579e1ff](https://github.com/vuejs/vue/commit/579e1ff9df1d454f85fac386d098b7bf1a42c4f2)), closes [#10843](https://github.com/vuejs/vue/issues/10843)
- **errorHandler:** async error handling for watchers ([#9484](https://github.com/vuejs/vue/issues/9484)) ([e4dea59](https://github.com/vuejs/vue/commit/e4dea59f84dfbf32cda1cdd832380dd90b1a6fd1))
- force update between two components with and without slot ([#11795](https://github.com/vuejs/vue/issues/11795)) ([77b5330](https://github.com/vuejs/vue/commit/77b5330c5498a6b14a83197371e9a2dbf9939a9c))

+ 30 more matches in this file

examples/classic/commits/app.js JAVASCRIPT 7 matches · showing 5 view file →

  data: {
    branches: ['main', 'dev'],
    currentBranch: 'main',
    commits: null

· · ·

    currentBranch: 'main',
    commits: null
  },

· · ·

  created: function () {
    this.fetchData()
  },

· · ·

  filters: {
    truncate: function (v) {
      var newline = v.indexOf('\n')
      return newline > 0 ? v.slice(0, newline) : v

· · ·

    },
    formatDate: function (v) {
      return v.replace(/T|Z/g, ' ')
    }

+ 2 more matches in this file

examples/classic/firebase/app.js JAVASCRIPT 6 matches · showing 5 view file →

var config = {
  apiKey: "AIzaSyAi_yuJciPXLFr_PYPeU3eTvtXf8jbJ8zw",
  authDomain: "vue-demo-537e6.firebaseapp.com",
  databaseURL: "https://vue-demo-537e6.firebaseio.com"
}

· · ·

  // computed property for form validation state
  computed: {
    validation: function () {
      return {
        name: !!this.newUser.name.trim(),

· · ·

      }
    },
    isValid: function () {
      var validation = this.validation
      return Object.keys(validation).every(function (key) {

· · ·

      return Object.keys(validation).every(function (key) {
        return validation[key]
      })

· · ·

  // methods
  methods: {
    addUser: function () {
      if (this.isValid) {
        usersRef.push(this.newUser)

+ 1 more matches in this file

examples/classic/todomvc/app.js JAVASCRIPT 24 matches · showing 5 view file →

var STORAGE_KEY = 'todos-vuejs-2.0'
var todoStorage = {
  fetch: function () {
    var todos = JSON.parse(localStorage.getItem(STORAGE_KEY) || '[]')
    todos.forEach(function (todo, index) {

· · ·

    todos.forEach(function (todo, index) {
      todo.id = index
    })

· · ·

    return todos
  },
  save: function (todos) {
    localStorage.setItem(STORAGE_KEY, JSON.stringify(todos))
  }

· · ·

// visibility filters
var filters = {
  all: function (todos) {
    return todos
  },

· · ·

  active: function (todos) {
    return todos.filter(function (todo) {
      return !todo.completed

+ 19 more matches in this file

examples/composition/todomvc.html HTML 19 matches · showing 5 view file →

      />
    </header>
    <section class="main" v-show="state.todos.length">
      <input
        id="toggle-all"

· · ·

    <footer class="footer" v-show="state.todos.length">
      <span class="todo-count">
        <strong>{{ state.remaining }}</strong>
        <span>{{ state.remainingText }}</span>
      </span>

· · ·

        <span>{{ state.remainingText }}</span>
      </span>
      <ul class="filters">

· · ·

        class="clear-completed"
        @click="removeCompleted"
        v-show="state.todos.length > state.remaining"
      >
        Clear completed

· · ·

    },
    completed(todos) {
      return todos.filter(function (todo) {
        return todo.completed
      })

+ 14 more matches in this file

packages/compiler-sfc/src/babelUtils.ts TYPESCRIPT 25 matches · showing 5 view file →

// https://github.com/vuejs/core/blob/main/packages/compiler-core/src/babelUtils.ts
// should only use types from @babel/types

· · ·

  Identifier,
  Node,
  Function,
  ObjectProperty,
  BlockStatement,

· · ·

import { walk } from 'estree-walker'
export function walkIdentifiers(
  root: Node,
  onIdentifier: (

· · ·

        // mark property in destructure pattern
        ;(node as any).inPattern = true
      } else if (isFunctionType(node)) {
        // walk function expressions and add its arguments to known identifiers
        // so that we don't prefix them

· · ·

        // walk function expressions and add its arguments to known identifiers
        // so that we don't prefix them
        walkFunctionParams(node, id => markScopeIdentifier(node, id, knownIds))

+ 20 more matches in this file

packages/compiler-sfc/src/compileScript.ts TYPESCRIPT 64 matches · showing 5 view file →

import MagicString from 'magic-string'
import LRU from 'lru-cache'
import { walkIdentifiers, isFunctionType } from './babelUtils'
import { BindingMetadata, BindingTypes } from './types'
import { SFCDescriptor, SFCScriptBlock } from './parseComponent'

· · ·

  TSType,
  TSTypeLiteral,
  TSFunctionType,
  ObjectProperty,
  ArrayExpression,

· · ·

 * normal `<script>` + `<script setup>` if both are present.
 */
export function compileScript(
  sfc: SFCDescriptor,
  options: SFCScriptCompileOptions = { id: '' }

· · ·

  let emitsRuntimeDecl: Node | undefined
  let emitsTypeDecl:
    | TSFunctionType
    | TSTypeLiteral
    | TSInterfaceBody

· · ·

  const scriptEndOffset = script && script.end
  function helper(key: string): string {
    helperImports.add(key)
    return `_${key}`

+ 59 more matches in this file

packages/compiler-sfc/src/compileTemplate.ts TYPESCRIPT 12 matches · showing 5 view file →

  transpileOptions?: any
  isProduction?: boolean
  isFunctional?: boolean
  optimizeSSR?: boolean
  prettify?: boolean

· · ·

}
export function compileTemplate(
  options: SFCTemplateCompileOptions
): SFCTemplateCompileResults {

· · ·

    return {
      ast: {},
      code: `var render = function () {}\n` + `var staticRenderFns = []\n`,
      source: options.source,
      tips: [

· · ·

}
function preprocess(
  options: SFCTemplateCompileOptions,
  preprocessor: any

· · ·

}
function actuallyCompile(
  options: SFCTemplateCompileOptions
): SFCTemplateCompileResults {

+ 7 more matches in this file

packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap 12 matches · showing 5 view file →

        const a = 1
        function b() {}
        
return { a, b, Baz }

· · ·

      let aa = 1
      const bb = 2
      function cc() {}
      class dd {}
      

· · ·

      let a = 1
      const b = 2
      function c() {}
      class d {}
      

· · ·

`;
exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (referenced exported function type) 1`] = `
"import { defineComponent as _defineComponent } from 'vue'
export type Emits = (e: 'foo' | 'bar') => void

· · ·

`;
exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (referenced function type) 1`] = `
"import { defineComponent as _defineComponent } from 'vue'
type Emits = (e: 'foo' | 'bar') => void

+ 7 more matches in this file

packages/compiler-sfc/test/compileScript.spec.ts TYPESCRIPT 17 matches · showing 5 view file →

      let a = 1
      const b = 2
      function c() {}
      class d {}
      </script>

· · ·

      let aa = 1
      const bb = 2
      function cc() {}
      class dd {}
      </script>

· · ·

        import { Foo, Baz, Qux, Fred } from './x'
        const a = 1
        function b() {}
        </script>
        <template>

· · ·

  //   test('avoid unref() when necessary', () => {
  //     // function, const, component import
  //     const { content } = compile(
  //       `<script setup>

· · ·

  //       const maybe = foo()
  //       let lett = 1
  //       function fn() {}
  //       </script>
  //       <template>

+ 12 more matches in this file

packages/compiler-sfc/test/rewriteDefault.spec.ts TYPESCRIPT 6 matches · showing 5 view file →

  test('export named default multiline', () => {
    expect(
      rewriteDefault(`let App = {}\n export {\nApp as default\n}`, '_sfc_main')
    ).toMatchInlineSnapshot(`
      "let App = {}

· · ·

      
      }
      const _sfc_main = App"
    `)
  })

· · ·

      rewriteDefault(
        `const a = 1 \n export {\n a as b,\n a as default,\n a as c}\n` +
          `// export { myFunction as default }`,
        'script'
      )

· · ·

       
       a as c}
      // export { myFunction as default }
      const script = a"
    `)

· · ·

      rewriteDefault(
        `const a = 1 \n export {\n a as b,\n a as default      ,\n a as c}\n` +
          `// export { myFunction as default }`,
        'script'
      )

+ 1 more matches in this file

packages/server-renderer/test/ssr-template.spec.ts TYPESCRIPT 9 matches · showing 5 view file →

const interpolateTemplate = `<html><head><title>{{ title }}</title></head><body><!--vue-ssr-outlet-->{{{ snippet }}}</body></html>`
async function generateClientManifest(file: string) {
  const fs = await compileWithWebpack(file, {
    output: {

· · ·

}
async function createRendererWithManifest(
  file: string,
  options?: RenderOptions

· · ·

  })
  it('renderToString w/ template function', async () => {
    const renderer = createRenderer({
      template: (content, context) =>

· · ·

  })
  it('renderToString w/ template function returning Promise', async () => {
    const renderer = createRenderer({
      template: (content, context) =>

· · ·

  })
  it('renderToString w/ template function returning Promise w/ rejection', async () => {
    const renderer = createRenderer({
      template: () =>

+ 4 more matches in this file

packages/template-compiler/README.md MARKDOWN 15 matches · showing 5 view file →

> This package is auto-generated. For pull requests please see [src/platforms/web/entry-compiler.js](https://github.com/vuejs/vue/tree/dev/src/platforms/web/entry-compiler.js).
This package can be used to pre-compile Vue 2.0 templates into render functions to avoid runtime-compilation overhead and CSP restrictions. In most cases you should be using it with [`vue-loader`](https://github.com/vuejs/vue-loader), you will only need it separately if you are writing build tools with very specific needs.
## Installation

· · ·

{
  ast: ?ASTElement, // parsed template elements to AST
  render: string, // main render function code
  staticRenderFns: Array<string>, // render code for static sub trees, if any
  errors: Array<string> // template syntax errors, if any

· · ·

```
Note the returned function code uses `with` and thus cannot be used in strict mode code.
#### Options

· · ·

- `directives`
  An object where the key is the directive name and the value is a function that transforms an template AST node. For example:
  ``` js

· · ·

  ```
  By default, a compile-time directive will extract the directive and the directive will not be present at runtime. If you want the directive to also be handled by a runtime definition, return `true` in the transform function.
  Refer to the implementation of some [built-in compile-time directives](https://github.com/vuejs/vue/tree/dev/src/platforms/web/compiler/directives).

+ 10 more matches in this file

pnpm-lock.yaml YAML 16 matches · showing 5 view file →

    resolution: {integrity: sha512-C3nQxfFZxFRVoJoGKKI8y3MOEo129NQ+FgQ08iye+Mk4zNZZGdjfs06bVTr+DBSlA66Q2VEcMki/cUCP4SercQ==}
    dependencies:
      function-bind: 1.1.2
      get-intrinsic: 1.2.2
      set-function-length: 1.1.1

· · ·

      set-function-length: 1.1.1
    dev: true

· · ·

      check-error: 1.0.3
      deep-eql: 4.1.3
      get-func-name: 2.0.2
      loupe: 2.3.7
      pathval: 1.1.1

· · ·

    resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==}
    dependencies:
      get-func-name: 2.0.2
    dev: true

· · ·

    dev: true
  /compare-func@2.0.0:
    resolution: {integrity: sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==}
    dependencies:

+ 11 more matches in this file

scripts/release.js JAVASCRIPT 4 matches view file →

const step = msg => console.log(chalk.cyan(msg))
async function main() {
  let targetVersion = args._[0]

· · ·

}
function updatePackage(pkgRoot, version) {
  const pkgPath = path.resolve(pkgRoot, 'package.json')
  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))

· · ·

    : path.resolve(__dirname, '../packages/' + pkg)
async function publishPackage(pkgName, version, runIfNotDry) {
  const pkgRoot = getPkgRoot(pkgName)
  const pkgPath = path.resolve(pkgRoot, 'package.json')

· · ·

}
main()

src/compiler/parser/html-parser.ts TYPESCRIPT 8 matches · showing 5 view file →

  tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
function decodeAttr(value, shouldDecodeNewlines) {
  const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
  return value.replace(re, match => decodingMap[match])

· · ·

}
export function parseHTML(html, options: HTMLParserOptions) {
  const stack: any[] = []
  const expectHTML = options.expectHTML

· · ·

          'i'
        ))
      const rest = html.replace(reStackedTag, function (all, text, endTag) {
        endTagLength = endTag.length
        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {

· · ·

  }
  // Clean up any remaining tags
  parseEndTag()

· · ·

  function advance(n) {
    index += n
    html = html.substring(n)

+ 3 more matches in this file

src/platforms/web/compiler/modules/model.ts TYPESCRIPT 3 matches view file →

import { ASTElement, CompilerOptions, ModuleOptions } from 'types/compiler'
function preTransformNode(el: ASTElement, options: CompilerOptions) {
  if (el.tag === 'input') {
    const map = el.attrsMap

· · ·

      // 1. checkbox
      const branch0 = cloneASTElement(el)
      // process for on the main node
      processFor(branch0)
      addRawAttr(branch0, 'type', 'checkbox')

· · ·

}
function cloneASTElement(el) {
  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
}

src/platforms/web/runtime/components/transition-group.ts TYPESCRIPT 7 matches · showing 5 view file →

// triggering their leaving transition; in the second pass, we insert/move
// into the final desired state. This way in the second pass removed
// nodes will remain where they should be.
import { warn, extend } from 'core/util/index'

· · ·

  },
  render(h: Function) {
    const tag: string = this.tag || this.$vnode.data.tag || 'span'
    const map: Record<string, any> = Object.create(null)

· · ·

        el.addEventListener(
          transitionEndEvent,
          (el._moveCb = function cb(e) {
            if (e && e.target !== el) {
              return

· · ·

}
function callPendingCbs(
  c: VNodeWithData & { elm?: { _moveCb?: Function; _enterCb?: Function } }
) {

· · ·

  c: VNodeWithData & { elm?: { _moveCb?: Function; _enterCb?: Function } }
) {
  /* istanbul ignore if */

+ 2 more matches in this file

src/platforms/web/util/element.ts TYPESCRIPT 3 matches view file →

  'html,body,base,head,link,meta,style,title,' +
    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +

· · ·

}
export function getTagNamespace(tag: string): string | undefined {
  if (isSVG(tag)) {
    return 'svg'

· · ·

const unknownElementCache = Object.create(null)
export function isUnknownElement(tag: string): boolean {
  /* istanbul ignore if */
  if (!inBrowser) {

test/e2e/commits.spec.ts TYPESCRIPT 5 matches view file →

  const { page, click, count, text, isChecked } = setupPuppeteer()
  async function testCommits(apiType: 'classic' | 'composition') {
    // intercept and mock the response to avoid hitting the actual API
    await page().setRequestInterception(true)

· · ·

        req.continue()
      } else {
        const ret = JSON.stringify(mocks[match[1] as 'main' | 'dev'])
        req.respond({
          status: 200,

· · ·

    expect(await count('input')).toBe(2)
    expect(await count('label')).toBe(2)
    expect(await text('label[for="main"]')).toBe('main')
    expect(await text('label[for="dev"]')).toBe('dev')
    expect(await isChecked('#main')).toBe(true)

· · ·

    expect(await isChecked('#main')).toBe(true)
    expect(await isChecked('#dev')).toBe(false)
    expect(await text('p')).toBe('vuejs/vue@main')

· · ·

    expect(await text('p')).toBe('vuejs/vue@main')
    expect(await count('li')).toBe(3)
    expect(await count('li .commit')).toBe(3)

test/e2e/todomvc.spec.ts TYPESCRIPT 4 matches view file →

  } = setupPuppeteer()
  async function removeItemAt(n: number) {
    const item = (await page().$('.todo:nth-child(' + n + ')'))!
    const itemBBox = (await item.boundingBox())!

· · ·

  }
  async function testTodomvc(apiType: 'classic' | 'composition') {
    const baseUrl = getExampleUrl('todomvc', apiType)
    await page().goto(baseUrl)

· · ·

    expect(await isVisible('.main')).toBe(false)
    expect(await isVisible('.footer')).toBe(false)
    expect(await count('.filters .selected')).toBe(1)

· · ·

    expect(await text('.todo-count strong')).toBe('1')
    expect(await isChecked('.todo .toggle')).toBe(false)
    expect(await isVisible('.main')).toBe(true)
    expect(await isVisible('.footer')).toBe(true)
    expect(await isVisible('.clear-completed')).toBe(false)

test/unit/features/component/component-keep-alive.spec.ts TYPESCRIPT 9 matches · showing 5 view file →

  })
  function assertHookCalls(component, callCounts) {
    expect([
      component.created.mock.calls.length,

· · ·

        expect(vm.$el.textContent).toBe('')
        assertHookCalls(one, [1, 1, 4, 3, 0])
        assertHookCalls(two, [1, 1, 4, 4, 0]) // should remain inactive
      })
      .then(done)

· · ·

  })
  function sharedAssertions(vm, done) {
    expect(vm.$el.textContent).toBe('one')
    assertHookCalls(one, [1, 1, 1, 0, 0])

· · ·

    const spyCD = vi.fn()
    function assertCount(calls) {
      expect([
        spyA.mock.calls.length,

· · ·

    const spyCD = vi.fn()
    function assertCount(calls) {
      expect([
        spyA.mock.calls.length,

+ 4 more matches in this file

test/unit/modules/compiler/parser.spec.ts TYPESCRIPT 5 matches view file →

  })
  it('preserve whitespace in <pre> tag', function () {
    const options = extend({}, baseOptions)
    const ast = parse(

· · ·

  // #5992
  it('ignore the first newline in <pre> tag', function () {
    const options = extend({}, baseOptions)
    const ast = parse(

· · ·

  })
  it(`maintains &nbsp; with whitespace: 'condense'`, () => {
    const options = extend({}, condenseOptions)
    const ast = parse('<span>&nbsp;</span>', options)

· · ·

  })
  it(`preserve whitespace in <pre> tag with whitespace: 'condense'`, function () {
    const options = extend({}, condenseOptions)
    const ast = parse(

· · ·

  })
  it(`ignore the first newline in <pre> tag with whitespace: 'condense'`, function () {
    const options = extend({}, condenseOptions)
    const ast = parse(

test/unit/modules/vdom/patch/children.spec.ts TYPESCRIPT 12 matches · showing 5 view file →

import VNode, { createEmptyVNode } from 'core/vdom/vnode'
function prop(name) {
  return obj => {
    return obj[name]

· · ·

}
function map(fn, list) {
  const ret: any[] = []
  for (let i = 0; i < list.length; i++) {

· · ·

}
function spanNum(n) {
  if (typeof n === 'string') {
    return new VNode('span', {}, undefined, n)

· · ·

}
function shuffle(array) {
  let currentIndex = array.length
  let temporaryValue

· · ·

  let randomIndex
  // while there remain elements to shuffle...
  while (currentIndex !== 0) {
    // pick a remaining element...

+ 7 more matches in this file

`auth login`	both terms (AND is implicit)
`auth OR login`	either term
`NOT path:vendor`	exclude matches
`"exact phrase"`	quoted exact match
`/func\s+Test/`	regex
`handler~1`	fuzzy (Levenshtein 1)
`file:*_test.go`	filename glob
`path:pkg/auth/**`	full path glob
`lang:go`	language filter

Search any public repo from your terminal