How to use normalizeProperty method in wpt

Best JavaScript code snippet using wpt

index.js

Source:index.js

...62}63function normalizeType(type, ...args) {64  return call(normalizers, `normalize_${type}`, ...args)65}66function normalizeProperty(type, property, propertyType, ...args) {67  return call(normalizers, `normalize_${type}_${property}_${propertyType}`, ...args)68}69const normalizers = {70  ...buildNormalizers(types),71  normalize_Identifier,72  normalize_Literal,73  normalize_Program,74  normalize_Super,75  normalize_ExpressionStatement,76  normalize_Directive,77  normalize_BlockStatement,78  normalize_FunctionBody,79  normalize_EmptyStatement,80  normalize_DebuggerStatement,81  normalize_WithStatement,82  normalize_ReturnStatement,83  normalize_LabeledStatement,84  normalize_BreakStatement,85  normalize_ContinueStatement,86  normalize_IfStatement,87  normalize_SwitchStatement,88  normalize_SwitchCase,89  normalize_ThrowStatement,90  normalize_TryStatement,91  normalize_CatchClause,92  normalize_BigIntLiteral,93  normalize_WhileStatement,94  normalize_DoWhileStatement,95  normalize_ForStatement,96  normalize_ForInStatement,97  normalize_ForOfStatement,98  normalize_FunctionDeclaration,99  normalize_VariableDeclaration,100  normalize_VariableDeclarator,101  normalize_ThisExpression,102  normalize_ArrayExpression,103  normalize_ObjectExpression,104  normalize_Property,105  normalize_FunctionExpression,106  normalize_ArrowFunctionExpression,107  normalize_YieldExpression,108  normalize_TemplateLiteral,109  normalize_TaggedTemplateExpression,110  normalize_TemplateElement,111  normalize_UnaryExpression,112  normalize_UpdateExpression,113  normalize_BinaryExpression,114  normalize_AssignmentExpression,115  normalize_LogicalExpression,116  normalize_MemberExpression,117  normalize_ConditionalExpression,118  normalize_CallExpression,119  normalize_NewExpression,120  normalize_SequenceExpression,121  normalize_SpreadElement,122  normalize_ArrayPattern,123  normalize_ObjectPattern,124  normalize_RestElement,125  normalize_AssignmentPattern,126  normalize_ClassBody,127  normalize_MethodDefinition,128  normalize_ClassDeclaration,129  normalize_ClassExpression,130  normalize_MetaProperty,131  normalize_ModuleDeclaration,132  normalize_ModuleSpecifier,133  normalize_ImportDeclaration,134  normalize_ImportSpecifier,135  normalize_ImportDefaultSpecifier,136  normalize_ImportNamespaceSpecifier,137  normalize_ExportNamedDeclaration,138  normalize_ExportSpecifier,139  normalize_ExportDefaultDeclaration,140  normalize_ExportAllDeclaration,141  normalize_AwaitExpression,142  normalize_ImportExpression,143  normalize_null,144}145function normalize_null() {146  return [null, []]147}148function normalize_Identifier(node, scope) {149  return [node, []]150}151function normalize_Literal(node, scope) {152  return [node, []]153}154function normalize_Program(node, scope) {155  const body = []156  node.body.forEach(n => {157    const [normalizedNode, normalizedExpressions]158      = normalizeProperty(node.type, 'body', n.type, n, scope)159    if (normalizedNode.type === 'EmptyStatement') return160    body.push(...normalizedExpressions)161    if (Array.isArray(normalizedNode)) {162      body.push(...normalizedNode)163    } else {164      body.push(normalizedNode)165    }166  })167  return createProgram(body)168}169function normalize_Super(node, scope) {170}171function normalize_ExpressionStatement(node, scope) {172  return normalizeProperty(node.type, 'expression', node.expression.type, node.expression, scope)173}174function normalize_Directive(node, scope) {175}176function normalize_BlockStatement(node, scope) {177  const body = []178  node.body.forEach(bd => {179    const [data, expressions] = normalizeProperty(node.type, 'body', bd.type, bd, scope)180    if (data.type === 'EmptyStatement') return181    body.push(...expressions)182    if (Array.isArray(data)) {183      body.push(...data)184    } else {185      body.push(data)186    }187  })188  return [189    createBlockStatement(body),190    []191  ]192}193function normalize_FunctionBody(node, scope) {194}195function normalize_EmptyStatement(node, scope) {196  return [node, []]197}198function normalize_DebuggerStatement(node, scope) {199  return [node, []]200}201function normalize_WithStatement(node, scope) {202}203function normalize_ReturnStatement(node, scope) {204  const exps = []205  const [argument, argumentExps]206    = normalizeProperty(node.type, 'argument', node.argument?.type ?? null, node.argument, scope, false)207  exps.push(...argumentExps)208  return [209    createReturnStatement(argument),210    exps211  ]212}213function normalize_LabeledStatement(node, scope) {214  const [body] = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)215  const [label] = normalizeProperty(node.type, 'label', node.label.type, node.label, scope)216  return [217    createLabeledStatement(label, body),218    []219  ]220}221function normalize_BreakStatement(node, scope) {222  return [223    node,224    []225  ]226}227function normalize_ContinueStatement(node, scope) {228  return [node, []]229}230function normalize_IfStatement(node, scope) {231  const top = []232  const [test, testExps] = normalizeProperty(node.type, 'test', node.test.type, node.test, scope, false)233  top.push(...testExps)234  let [consequent, consequentExps]235    = normalizeProperty(node.type, 'consequent', node.consequent.type, node.consequent, scope)236  if (consequent.type !== 'BlockStatement') {237    consequent = createBlockStatement([consequent])238  }239  let alternate = null240  let alternateExps241  if (node.alternate) {242    [alternate, alternateExps]243      = normalizeProperty(node.type, 'alternate', node.alternate.type, node.alternate, scope)244    if (alternate.type === 'IfStatement') {245      top.push(...alternateExps)246    } else if (alternate.type !== 'BlockStatement') {247      alternate = createBlockStatement([alternate])248    }249  }250  const ifStatement = createIfStatement(test, consequent, alternate)251  return [ifStatement, top]252}253function normalize_SwitchStatement(node, scope) {254  const exps = []255  const [discriminant, discriminantExps]256    = normalizeProperty(node.type, 'discriminant', node.discriminant.type, node.discriminant, scope)257  exps.push(...discriminantExps)258  const cases = []259  node.cases.forEach(cse => {260    const [c, caseExps] = normalizeProperty(node.type, 'cases', cse.type, cse, scope)261    cases.push(c)262    exps.push(...caseExps)263  })264  return [265    createSwitchStatement(discriminant, cases),266    exps267  ]268}269function normalize_SwitchCase(node, scope) {270  const exps = []271  const consequent = []272  node.consequent.forEach(c => {273    const [cons, consExps] = normalizeProperty(node.type, 'consequent', c.type, c, scope)274    if (Array.isArray(cons)) {275      consequent.push(...cons)276    } else {277      consequent.push(cons)278    }279    exps.push(...consExps)280  })281  const [test, testExps]282    = normalizeProperty(node.type, 'test', node.test?.type ?? null, node.test, scope)283  exps.push(...testExps)284  return [285    createSwitchCase(test, consequent),286    exps287  ]288}289function normalize_ThrowStatement(node, scope) {290  const [argument, argumentExps] = normalizeProperty(node.type, 'argument', node.argument.type, node.argument, scope)291  return [292    createThrowStatement(argument),293    argumentExps294  ]295}296function normalize_TryStatement(node, scope) {297  const exps = []298  const [block, blockExps]299    = normalizeProperty(node.type, 'block', node.block.type, node.block, scope)300  const [handler, handlerExps]301    = normalizeProperty(node.type, 'handler', node.handler.type, node.handler, scope)302  const [finalizer, finalizerExps]303    = normalizeProperty(node.type, 'finalizer', node.finalizer?.type ?? null, node.finalizer, scope)304  return [305    createTryStatement(block, handler, finalizer),306    exps307  ]308}309function normalize_CatchClause(node, scope) {310  const exps = []311  const [param]312    = normalizeProperty(node.type, 'param', node.param?.type ?? null, node.param, scope)313  const [body, bodyExps]314    = normalizeProperty(node.type, 'body', node.body?.type, node.body, scope)315  exps.push(...bodyExps)316  return [317    createCatchClause(param, body),318    exps319  ]320}321function normalize_BigIntLiteral(node, scope) {322}323function normalize_WhileStatement(node, scope) {324  const [test, testExps]325    = normalizeProperty(node.type, 'test', node.test.type, node.test, scope, false)326  let [body, bodyExps]327    = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)328  if (body.type !== 'BlockStatement') {329    body = createBlockStatement([body])330  }331  body.body.unshift(...bodyExps)332  let newBody333  let simple = false334  if (test.type === 'Literal' && test.value === true) {335    newBody = body.body336    simple = true337  } else {338    newBody = [339      ...testExps,340      createIfStatement(341        test,342        body,343        createBlockStatement([344          createBreakStatement()345        ])346      )347    ]348  }349  const whileStatement = createWhileStatement(createLiteral(true), newBody)350  whileStatement.simple = simple351  return [whileStatement, []]352}353function normalize_DoWhileStatement(node, scope) {354  const [test, testExps]355    = normalizeProperty(node.type, 'test', node.test.type, node.test, scope, true)356  const [body, bodyExps]357    = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)358  body.body.unshift(...bodyExps)359  const newBody = [360    ...testExps,361    createIfStatement(362      test,363      body,364      createBlockStatement([365        createBreakStatement()366      ])367    )368  ]369  const whileStatement = createWhileStatement(createLiteral(true), newBody)370  return [whileStatement, []]371}372function normalize_ForStatement(node, scope) {373  let [init, initExps] = normalizeProperty(node.type, 'init', node.init?.type ?? null, node.init, scope)374  const [test, testExps] = normalizeProperty(node.type, 'test', node.test?.type ?? null, node.test, scope, false)375  let [update, updateExps] = normalizeProperty(node.type, 'update', node.update?.type ?? null, node.update, scope)376  let [body, bodyExps] = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)377  if (init) {378    if (!Array.isArray(init)) init = [init]379  } else {380    init = []381  }382  if (update) {383    if (!Array.isArray(update)) update = [update]384  } else {385    update = []386  }387  if (body.type !== 'BlockStatement') {388    body = createBlockStatement(Array.isArray(body) ? body : [body])389  }390  const label = `fork${scope.index++}`391  const block = createBlockStatement([392    ...initExps,393    ...init,394    createLabeledStatement(label),395    createWhileStatement(396      createLiteral(true),397      [398        ...testExps,399        createIfStatement(test,400          createBlockStatement([401            ...body.body,402            ...updateExps,403            ...update404          ]),405          createBlockStatement([406            createBreakStatement(label)407          ])408        )409      ]410    )411  ])412  return [block, []]413}414function normalize_ForInStatement(node, scope) {415  const exps = []416  const [left, leftExps]417    = normalizeProperty(node.type, 'left', node.left.type, node.left, scope)418  const [right, rightExps]419    = normalizeProperty(node.type, 'right', node.right.type, node.right, scope)420  const [body, bodyExps]421    = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)422  exps.push(...leftExps)423  exps.push(...rightExps)424  const forInStatement = createForInStatement(Array.isArray(left) ? left[0] : left, right, body)425  return [forInStatement, exps]426}427function normalize_ForOfStatement(node, scope) {428  const exps = []429  const [left, leftExps]430    = normalizeProperty(node.type, 'left', node.left.type, node.left, scope)431  const [right, rightExps]432    = normalizeProperty(node.type, 'right', node.right.type, node.right, scope)433  const [body, bodyExps]434    = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)435  exps.push(...leftExps)436  exps.push(...rightExps)437  const forOfStatement = createForOfStatement(left, right, body)438  return [forOfStatement, exps]439}440function normalize_FunctionDeclaration(node, scope) {441  const exps = []442  const params = []443  node.params.forEach(param => {444    const [p, pExps]445      = normalizeProperty(node.type, 'params', param.type, param, scope)446    // TODO: move this inside the function.447    exps.push(...pExps)448    params.push(p)449  })450  const [body]451    = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)452  return [453    createFunctionDeclaration(node.id, params, body),454    exps455  ]456}457function normalize_VariableDeclaration(node, scope) {458  const exps = []459  const declarations = []460  node.declarations.forEach(dec => {461    const [declarators, expressions] = normalize_VariableDeclarator(dec, scope)462    exps.push(...expressions)463    declarators.forEach(declarator => {464      declarations.push(createVariableDeclaration(node.kind, [declarator]))465    })466  })467  return [declarations, exps]468}469function normalize_VariableDeclarator(node, scope) {470  const exps = []471  const [id, idExps] = normalizeProperty(node.type, 'id', node.id.type, node.id, scope)472  const [init, initExps] = normalizeProperty(node.type, 'init', node.init?.type ?? null, node.init, scope, false)473  exps.push(...idExps)474  exps.push(...initExps)475  const declarators = []476  // TODO: handle nested of these more carefully.477  if (id.type === 'ArrayPattern') {478    id.elements.forEach((i, _i) => {479      declarators.push(480        createVariableDeclarator(i,481          createMemberExpression(init, createLiteral(_i), true)482        )483      )484    })485  // TODO: handle nested of these more carefully.486  } else if (id.type === 'ObjectPattern') {487    id.properties.forEach((i, _i) => {488      declarators.push(489        createVariableDeclarator(i.value,490          createMemberExpression(init, i.key)491        )492      )493    })494  } else {495    declarators.push(createVariableDeclarator(id, init))496  }497  return [498    declarators,499    exps500  ]501}502function normalize_ThisExpression(node, scope) {503  return [504    node,505    []506  ]507}508function normalize_ArrayExpression(node, scope, isolate) {509  const exps = []510  const array = []511  node.elements.forEach(element => {512    const [el, elExps] = normalizeProperty(node.type, 'elements', element.type, element, scope, false)513    array.push(el)514    exps.push(...elExps)515  })516  const arrayExp = createArrayExpression(array)517  if (isolate == 'hey') {518    const name = `tmp${scope.index++}`519    exps.push(520      createVariable('const',521        createIdentifier(name),522        arrayExp523      )524    )525    return [526      createIdentifier(name),527      exps528    ]529  } else {530    return [531      arrayExp,532      exps533    ]534  }535}536function normalize_ObjectExpression(node, scope, isolate) {537  const exps = []538  const array = []539  node.properties.forEach(prop => {540    const [el, elExps] = normalizeProperty(node.type, 'properties', prop.type, prop, scope, false)541    array.push(el)542    exps.push(...elExps)543  })544  const objectExp = createObjectExpression(array)545  if (isolate) {546    const name = `tmp${scope.index++}`547    exps.push(548      createVariable('const',549        createIdentifier(name),550        objectExp551      )552    )553    return [554      createIdentifier(name),555      exps556    ]557  } else {558    return [559      objectExp,560      exps561    ]562  }563}564function normalize_Property(node, scope) {565  if (node.type === 'SpreadElement') {566    return normalizeSpreadElement(node, scope)567  } else if (node.type === 'ObjectPattern') {568    throw new Error569  }570  const exps = []571  const [key, keyExps] = normalizeProperty(node.type, 'key', node.key.type, node.key, scope)572  const [value, valueExps] = normalizeProperty(node.type, 'value', node.value.type, node.value, scope)573  exps.push(...keyExps)574  exps.push(...valueExps)575  return [createProperty(key, value), exps]576}577function normalize_FunctionExpression(node, scope) {578  const exps = []579  const params = []580  node.params.forEach(param => {581    const [p, pExps] = normalizeProperty(node.type, 'params', param.type, param, scope)582    exps.push(...pExps)583    params.push(p)584  })585  const [body] = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)586  return [587    createFunctionExpression(node.id, params, body),588    exps589  ]590}591function normalize_ArrowFunctionExpression(node, scope) {592  const exps = []593  const params = []594  node.params.forEach(param => {595    const [p, pExps] = normalizeProperty(node.type, 'params', param.type, param, scope)596    exps.push(...pExps)597    params.push(p)598  })599  let [body, bodyExps]600    = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)601  if (body.type !== 'BlockStatement') {602    body = createBlockStatement([...bodyExps, createReturnStatement(body)])603  }604  return [605    createArrowFunctionExpression(node.id, params, body),606    exps607  ]608}609function normalize_YieldExpression(node, scope) {610}611function normalize_TemplateLiteral(node, scope) {612  const exps = []613  const quasis = []614  const expressions = []615  node.expressions.forEach(expression => {616    const [exp, expExps] = normalizeProperty(node.type, 'expressions', expression.type, expression, scope, true)617    expressions.push(exp)618    exps.push(...expExps)619  })620  node.quasis.forEach(q => {621    const [el] = normalizeProperty(node.type, 'quasis', q.type, q, scope)622    quasis.push(el)623  })624  return [625    createTemplateLiteral(expressions, quasis),626    exps627  ]628}629function normalize_TaggedTemplateExpression(node, scope) {630  const [tag, tagExps]631    = normalizeProperty(node.type, 'tag', node.tag.type, node.tag, scope)632  const [template, templateExps]633    = normalizeProperty(node.type, 'quasi', node.quasi.type, node.quasi, scope)634  return [635    createTaggedTemplateExpression(tag, template),636    [...templateExps, ...tagExps]637  ]638}639function normalize_TemplateElement(node, scope) {640  return [node, []]641}642function normalize_UnaryExpression(node, scope, isolate) {643  const exps = []644  const [argument, argumentExps]645    = normalizeProperty(node.type, 'argument', node.argument.type, node.argument, scope, false)646  exps.push(...argumentExps)647  const unary = createUnaryExpression(argument, node.operator, node.prefix)648  if (isolate) {649    const name = `tmp${scope.index++}`650    exps.push(651      createVariable('const',652        createIdentifier(name),653        unary654      )655    )656    return [657      createIdentifier(name),658      exps659    ]660  } else {661    return [662      unary,663      exps664    ]665  }666}667function normalize_UpdateExpression(node, scope, isolate) {668  const [argument, argumentExps]669    = normalizeProperty(node.type, 'argument', node.argument.type, node.argument, scope, false)670  const update = createUpdateExpression(argument, node.operator, node.prefix)671  if (isolate) {672    const name = `tmp${scope.index++}`673    argumentExps.push(674      createVariable('const',675        createIdentifier(name),676        update677      )678    )679    return [680      createIdentifier(name),681      argumentExps682    ]683  } else {684    return [685      update,686      argumentExps687    ]688  }689}690function normalize_BinaryExpression(node, scope, isolate) {691  const exps = []692  const [left, leftExps]693    = normalizeProperty(node.type, 'left', node.left.type, node.left, scope, false)694  const [right, rightExps]695    = normalizeProperty(node.type, 'right', node.right.type, node.right, scope, false)696  exps.push(...leftExps)697  exps.push(...rightExps)698  const binary = createBinaryExpression(699    left,700    node.operator,701    right702  )703  if (isolate) {704    const name = `tmp${scope.index++}`705    exps.push(706      createVariable('const',707        createIdentifier(name),708        binary709      )710    )711    return [712      createIdentifier(name),713      exps714    ]715  } else {716    return [717      binary,718      exps719    ]720  }721}722function normalize_AssignmentExpression(node, scope, isolate) {723  const [left, leftExps] = normalizeProperty(node.type, 'left', node.left.type, node.left, scope)724  let values = [left]725  let operators = [node.operator]726  let right = node.right727  while (right.type === 'AssignmentExpression') {728    values.push(right.left)729    operators.push(right.operator)730    right = right.right731  }732  let [furthestRight, furthestRightExps] = normalizeProperty(node.type, 'right', right.type, right, scope, false)733  values.push(furthestRight)734  const exps = [735    ...leftExps,736    ...furthestRightExps737  ]738  if (left.type === 'ArrayPattern') {739    const assignments = []740    left.elements.forEach(el => {741      assignments.push(742        createAssignmentExpression(743          el,744          createMemberExpression(right, el),745          node.operator746        )747      )748    })749    return [750      assignments,751      exps752    ]753  } else {754    let assignments = []755    let i = 0756    let n = values.length - 1757    while (i < n) {758      let l = values[i]759      let r = values[i + 1]760      const assignment = createAssignmentExpression(l, r, operators[i])761      assignments.push(assignment)762      i++763    }764    assignments = assignments.reverse()765    let assignment766    if (isolate) {767      assignment = assignments[assignments.length - 1].left768    } else {769      assignment = assignments.pop()770    }771    return [772      assignment,773      exps.concat(assignments)774    ]775  }776}777function normalize_LogicalExpression(node, scope, isolate) {778  const exps = []779  const [left, leftExps]780    = normalizeProperty(node.type, 'left', node.left.type, node.left, scope, false)781  const [right, rightExps]782    = normalizeProperty(node.type, 'right', node.right.type, node.right, scope, false)783  exps.push(...leftExps)784  exps.push(...rightExps)785  const logicalExp = createLogicalExpression(786    left,787    node.operator,788    right789  )790  if (isolate) {791    const name = `tmp${scope.index++}`792    exps.push(793      createVariable('const',794        createIdentifier(name),795        logicalExp796      )797    )798    return [799      createIdentifier(name),800      exps801    ]802  } else {803    return [804      logicalExp,805      exps806    ]807  }808}809function normalize_MemberExpression(node, scope) {810  const exps = []811  const [object, objectStatements]812    = normalizeProperty(node.type, 'object', node.object.type, node.object, scope, true)813  const [property, propertyStatements]814    = normalizeProperty(node.type, 'property', node.property.type, node.property, scope, true)815  exps.push(...objectStatements)816  exps.push(...propertyStatements)817  return [818    createMemberExpression(819      object,820      property,821      node.computed822    ),823    exps824  ]825}826function normalize_ConditionalExpression(node, scope, isolate) {827  const exps = []828  const [test, testExps]829    = normalizeProperty(node.type, 'test', node.test.type, node.test, scope, true)830  const [consequent, consequentExps]831    = normalizeProperty(node.type, 'consequent', node.consequent.type, node.consequent, scope, true)832  const [alternate, alternateExps]833    = normalizeProperty(node.type, 'alternate', node.alternate.type, node.alternate, scope, true)834  exps.push(...testExps)835  exps.push(...consequentExps)836  exps.push(...alternateExps)837  const name = `tmp${scope.index++}`838  const conditional = createIfStatement(839    test,840    createBlockStatement([createAssignmentExpression(createIdentifier(name), consequent)]),841    createBlockStatement([createAssignmentExpression(createIdentifier(name), alternate)])842  )843  exps.push(844    createVariable('let',845      createIdentifier(name)846    ),847    conditional848  )849  return [850    createIdentifier(name),851    exps852  ]853}854function normalize_CallExpression(node, scope, isolate) {855  const [_callee, calleeExps]856    = normalizeProperty(node.type, 'callee', node.callee.type, node.callee, scope, true)857  const args = []858  const exps = []859  node.arguments.forEach(arg => {860    const [argument, argumentExps]861      = normalizeProperty(node.type, 'arguments', arg.type, arg, scope, false)862    exps.push(...argumentExps)863    args.push(argument)864  })865  exps.push(...calleeExps)866  if (isolate) {867    const name = `tmp${scope.index++}`868    exps.push(869      createVariableDeclaration('const', [870        createVariableDeclarator(871          createIdentifier(name),872          createCallExpression(_callee, args)873        )874      ])875    )876    return [877      createIdentifier(name),878      exps879    ]880  } else {881    return [882      createCallExpression(_callee, args),883      exps884    ]885  }886}887function normalize_NewExpression(node, scope) {888  const exps = []889  const [ctor, ctorExps]890    = normalizeProperty(node.type, 'callee', node.callee.type, node.callee, scope)891  const argExps = []892  const args = []893  node.arguments.forEach(arg => {894    const [argument, argumentExps]895      = normalizeProperty(node.type, 'arguments', arg.type, arg, scope, false)896    args.push(argument)897    argExps.push(...argumentExps)898  })899  exps.push(...ctorExps, ...argExps)900  return [901    createNewExpression(ctor, args),902    exps903  ]904}905function normalize_SequenceExpression(node, scope) {906  const expressions = []907  // this just flattens the list and gets rid of the node type908  // in the normalized output909  node.expressions.forEach(exp => {910    const exps = normalizeType(exp.type, exp, scope)911    expressions.push(...exps)912  })913  return expressions914}915function normalize_SpreadElement(node, scope) {916  const [arg, argExps]917    = normalizeProperty(node.type, 'argument', node.argument.type, node.argument, scope, true)918  return [919    createSpreadElement(arg),920    argExps921  ]922}923function normalize_ArrayPattern(node, scope) {924  const array = []925  const exps = []926  node.elements.forEach(element => {927    const [el, elExps] = normalizeProperty(node.type, 'elements', element.type, element, scope)928    array.push(el)929    exps.push(...elExps)930  })931  return [932    createArrayPattern(array),933    exps934  ]935}936function normalize_ObjectPattern(node, scope) {937  const exps = []938  const properties = []939  node.properties.forEach(p => {940    const [prop, propExps]941      = normalizeProperty(node.type, 'properties', p.type, p, scope)942    exps.push(...propExps)943    properties.push(prop)944  })945  return [946    createObjectPattern(properties),947    exps948  ]949}950function normalize_RestElement(node, scope) {951  const [arg, argExps]952    = normalizeProperty(node.type, 'argument', node.argument.type, node.argument, scope)953  return [954    createRestElement(arg),955    argExps956  ]957}958function normalize_AssignmentPattern(node, scope) {959  const exps = []960  const [left] = normalizeProperty(node.type, 'left', node.left.type, node.left, scope)961  const [right, rightExps] = normalizeProperty(node.type, 'right', node.right.type, node.right, scope, true)962  exps.push(...rightExps)963  return [964    createAssignmentPattern(left, right),965    exps966  ]967}968function normalize_ClassBody(node, scope) {969  const exps = []970  const body = []971  node.body.forEach(bd => {972    const [method, methodExps] = normalizeProperty(node.type, 'body', bd.type, bd, scope)973    exps.push(...methodExps)974    body.push(method)975  })976  return [createClassBody(body), exps]977}978function normalize_MethodDefinition(node, scope) {979  const [key, keyExps]980    = normalizeProperty(node.type, 'key', node.key.type, node.key, scope)981  const [value, valueExps]982    = normalizeProperty(node.type, 'value', node.value.type, node.value, scope)983  return [createMethodDefinition(key, value, node.kind, node.computed, node.static), keyExps]984}985function normalize_ClassDeclaration(node, scope) {986  const exps = []987  const [id, idExps]988    = normalizeProperty(node.type, 'id', node.id?.type ?? null, node.id, scope)989  const [superClass, superClassExps]990    = normalizeProperty(node.type, 'superClass', node.superClass?.type ?? null, node.superClass, scope)991  const [body, bodyExps]992    = normalizeProperty(node.type, 'body', node.body.type, node.body, scope)993  exps.push(...idExps)994  exps.push(...superClassExps)995  exps.push(...bodyExps)996  return [createClassDeclaration(id, superClass, body), exps]997}998function normalize_ClassExpression(node, scope) {999}1000function normalize_MetaProperty(node, scope) {1001}1002function normalize_ModuleDeclaration(node, scope) {1003}1004function normalize_ModuleSpecifier(node, scope) {1005}1006function normalize_ImportDeclaration(node, scope) {1007}1008function normalize_ImportSpecifier(node, scope) {1009}1010function normalize_ImportDefaultSpecifier(node, scope) {1011}1012function normalize_ImportNamespaceSpecifier(node, scope) {1013}1014function normalize_ExportNamedDeclaration(node, scope) {1015  const declaration = normalizeBodyNode(node.declaration, scope)1016  const specifiers = []1017}1018function normalize_ExportSpecifier(node, scope) {1019}1020function normalize_ExportDefaultDeclaration(node, scope) {1021}1022function normalize_ExportAllDeclaration(node, scope) {1023}1024function normalize_AwaitExpression(node, scope) {1025}1026function normalize_ImportExpression(node, scope) {1027}1028function call(obj, method, ...args) {1029  if (!obj.hasOwnProperty(method)) {1030    throw new Error(`Missing method ${method}`)1031  }1032  return obj[method](...args)1033}1034function buildNormalizers(types) {1035  const normalizers = {1036    normalize_null1037  }1038  Object.keys(types).forEach(type => {1039    const def = types[type]1040    normalizers[`normalize_${type}`] = buildNormalizeTypeFunction(type, def)1041  })1042  Object.keys(types).forEach(type => {1043    const def = types[type]1044    def.extends.type.forEach(extend => {1045      const parent = types[extend]1046      Object.keys(parent.properties).forEach(name => {1047        def.properties[name]1048          = def.properties[name]1049          || parent.properties[name]1050      })1051      Object.keys(def.properties).forEach(name => {1052        const searchableTypes = []1053        const stack = [...def.properties[name].type]1054        const processed = {}1055        while (stack.length) {1056          const propertyTypeName = stack.shift()1057          if (processed[propertyTypeName]) {1058            continue1059          }1060          processed[propertyTypeName] = true1061          searchableTypes.push(propertyTypeName)1062          const propertyType = types[propertyTypeName]1063          if (propertyType) {1064            propertyType.extends.type.forEach(ext => {1065              stack.push(ext)1066            })1067          }1068          Object.keys(types).forEach(childTypeName => {1069            const childType = types[childTypeName]1070            if (childType.extends.type.includes(propertyTypeName)) {1071              searchableTypes.push(childTypeName)1072              stack.push(childTypeName)1073            }1074          })1075        }1076        searchableTypes.forEach(searchedType => {1077          if (normalizers[`normalize_${searchedType}`]) {1078            normalizers[`normalize_${type}_${name}_${searchedType}`] = buildNormalizePropertyType(searchedType)1079          }1080        })1081      })1082    })1083  })1084  return normalizers1085}1086function buildNormalizePropertyType(propertyType) {1087  return function(node, scope, isolate) {1088    return normalizeType(propertyType, node, scope, isolate)1089  }1090}1091function buildNormalizeTypeFunction(type, def) {1092  return function(node, scope, isolate) {1093    const object = { type }1094    const expressions = []1095    Object.keys(def.properties).forEach(name => {1096      const property = def.properties[name]1097      if (property.list) {1098        const list = object[name] = []1099        const propertyNodes = node[name] ?? []1100        propertyNodes.forEach(propertyNode => {1101          const [normalizedPropertyNode, normalizedExpressions]1102            = normalizeProperty(type, name, propertyNode.type, propertyNode, scope, isolate)1103          list.push(normalizedPropertyNode)1104          expressions.push(...normalizedExpressions)1105        })1106      } else {1107        const propertyNode = node[name]1108        const [normalizedPropertyNode, normalizedExpressions]1109          = normalizeProperty(type, name, propertyNode?.type ?? null, propertyNode, scope, isolate)1110        object[name] = normalizedPropertyNode1111        expressions.push(...normalizedExpressions)1112      }1113    })1114    expressions.push(object)1115    return expressions1116  }...

restaurants.controller.ts

Source:restaurants.controller.ts

...12      constructor(@inject(TYPES.RestaurantsService) private restaurantsService: RestaurantsService) {13      }14      @httpPost('/')15      public getRestaurants(request: Request): Promise<IRestaurant[]> {16            return this.restaurantsService.getRestaurants(RestaurantsController.normalizeProperty(request.body.name), RestaurantsController.normalizeProperty(request.body.openAt), RestaurantsController.normalizeProperty(request.body.day))17      }18      /**19       * nullize empty values20       * @param prop21       * @private22       */23      private static normalizeProperty(prop: any): any {24            return prop === '' ? null : prop;25      }26      @httpGet('/test')27      public testPath(): {} {28            return {'dupa': 'zbita'};29      }...

normalizeProperty-test.ts

Source:normalizeProperty-test.ts

1import normalizeProperty from '../normalizeProperty'2describe('Normalizing properties', () => {3  it('should camel case hypenated properties', () => {4    expect(normalizeProperty('transition-delay')).toEqual('transitionDelay')5  })6  it('should unprefix properties', () => {7    expect(normalizeProperty('WebkitTransitionDelay')).toEqual(8      'transitionDelay'9    )10  })11  it('should unprefix and camel case properties', () => {12    expect(normalizeProperty('-webkit-transition-delay')).toEqual(13      'transitionDelay'14    )15  })...

Using AI Code Generation

1var wptools = require('wptools');2var wiki = new wptools('Barack Obama');3wiki.normalizeProperty('birth_place').then(function(response){4  console.log(response);5});6{ birth_place: 'Hawaii' }

Using AI Code Generation

1var wptools = require('wptools');2var page = wptools.page('Barack Obama');3page.normalizeProperty('wiki', function(err, result) {4    console.log(result);5});6var wptools = require('wptools');7var page = wptools.page('Barack Obama');8page.getTemplate('Infobox politician', function(err, result) {9    console.log(result);10});11var wptools = require('wptools');12var page = wptools.page('Barack Obama');13page.getTemplates(function(err, result) {14    console.log(result);15});

Using AI Code Generation

1const wptools = require('wptools');2wptools.normalizeProperty('P17', 'Q30').then(result => {3  console.log(result);4});5{ property: 'P17', value: 'Q30', normalized: true }6const wptools = require('wptools');7wptools.normalizeProperty('P17', 'Q30').then(result => {8  console.log(result);9});10{ property: 'P17', value: 'Q30', normalized: true }11const wptools = require('wptools');12wptools.normalizeProperty('P17', 'Q30').then(result => {13  console.log(result);14});15{ property: 'P17', value: 'Q30', normalized: true }16const wptools = require('wptools');17wptools.normalizeProperty('P17', 'Q30').then(result => {18  console.log(result);19});20{ property: 'P17', value: 'Q30', normalized: true }21const wptools = require('wptools');22wptools.normalizeProperty('P17', 'Q30').then(result => {23  console.log(result);24});25{ property: 'P17', value: 'Q30', normalized: true }

Using AI Code Generation

1const wptools = require('wptools');2wptools.normalizeProperty('P17', 'Q30').then(result => {3  console.log(result);4});5{ property: 'P17', value: 'Q30', normalized: true }6const wptools = require('wptools');7wptools.normalizeProperty('P17', 'Q30').then(result => {8  console.log(result);9});10{ property: 'P17', value: 'Q30', normalized: true }11const wptools = require('wptools');12wptools.normalizeProperty('P17', 'Q30').then(result => {13  console.log(result);14});15{ property: 'P17', value: 'Q30', normalized: true }16const wptools = require('wptools');17wptools.normalizeProperty('P17', 'Q30').then(result => {18  console.log(result);19});20{ property: 'P17', value: 'Q30', normalized: true }21const wptools = require('wptools');22wptools.normalizeProperty('P17', 'Q30').then(result => {23  console.log(result);24});25{ property: 'P17', value: 'Q30', normalized: true }

Using AI Code Generation

1var wpt = require('./wpt.js');2var property = "FirstView.SpeedIndex";3wpt.normalizeProperty(url, property, function(error, result){4  if(error) {5    console.log(error);6  }else {7    console.log(result);8  }9});10var wpt = require('./wpt.js');11var testId = "170123_0F_1";12wpt.getTestResults(testId, function(error, result){13  if(error) {14    console.log(error);15  }else {16    console.log(result);17  }18});19var wpt = require('./wpt.js');20var testId = "170123_0F_1";21var location = "Dulles:Chrome";22wpt.getTestResultsByLocation(testId, location, function(error, result){23  if(error) {24    console.log(error);25  }else {26    console.log(result);27  }28});29var wpt = require('./wpt.js');30var testId = "170123_0F_1";31var location = "Dulles:Chrome";32var connectivity = "Cable";33wpt.getTestResultsByLocationAndConnectivity(testId, location, connectivity, function(error, result){34  if(error) {35    console.log(error);36  }else {37    console.log(result);38  }39});40var wpt = require('./wpt.js');41wpt.getTestResultsByUrl(url, function(error, result){42  if(error)

Using AI Code Generation

1const wptools = require('wptools');2const normalizeProperty = wptools.normalizeProperty;3const normalizedProperty = normalizeProperty('P31');4console.log(normalizedProperty);5## normalizeValue()6const wptools = require('wptools');7const normalizeValue = wptools.normalizeValue;8const normalizedValue = normalizeValue('Q5');9console.log(normalizedValue);10## normalizeQualifier()11const wptools = require('wptools');12const normalizeQualifier = wptools.normalizeQualifier;13const normalizedQualifier = normalizeQualifier('P580');14console.log(normalizedQualifier);15## normalizeReference()16const wptools = require('wptools');17const normalizeReference = wptools.normalizeReference;18const normalizedReference = normalizeReference('P248');19console.log(normalizedReference);20```tpattern');

Using AI Code Generation

1var wptools = requir('wptools');2va wiki = wptools.page('Albert Eistein);3wiki.get(function(err, data) {4    if (err) {5        console.log(err);6    } else {7        console.log(data);8    }9}10## normalizeSnak()11const wptools = require('wptools');12const normalizeSnak = wptools.normalizeSnak;

Using AI Code Generation

1var wptools = require('wptools');2var wiki = wptools.page('Albert Einstein');3wiki.get(function(err, data) {4    if (err) {5        console.log(err);6    } else {7        console.log(data);8    }9});

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.