Top 10 Examples of "check-types in functional component" in JavaScript

function parseImmediateFunction(code) {
	//console.log('parsing immediate function');
	check.verify.string(code, 'missing code, have ' + code);
	var reg = /^\s*\(\s*function\s*\(\s*\)\s*\{([\W\w]*)}\s*(?:\)\s*\(\s*\)|\(\s*\)\s*\))/;

	var matched = reg.exec(code);
	// console.log('from code\n', code);
	// console.log('matched\n', matched);
	if (!Array.isArray(matched)) {
		return null;
	}
	if (!check.string(matched[1])) {
		return null;
	}

	var parsed = {
		code: matched[1].trim()
	};
	return parsed;
}

function parseNamedCode(code) {
	check.verify.string(code, 'missing code, have ' + code);
	var reg = /^\s*(?:it)\(([\W\w]+),\s*function\s*\(\)\s*\{([\W\w]*)\}\s*\)/;

	var matched = reg.exec(code);
	// console.log(matched);
	if (!check.array(matched)) {
		return null;
	}
	if (!check.string(matched[1])) {
		return null;
	}

	var parsed = {
		name: parseName(matched[1]),
		code: matched[2].trim()
	};
	return parsed;
}

function transformAssertion(line) {
    verify.string(line, 'missing line');
    // console.log('transforming line\n' + line);

    var parsed = null;
    lineParsers.some(function (method) {
        // console.log('checking', method.name, 'line', line);
        parsed = method(line);
        return parsed;
    });
    if (check.string(parsed)) {
        return parsed;
    }
    return line;
}

if (!check.object.of.number(exp.q)) throw Error("Queue must be key-value pairs of queue name and max processor count for that queue (inclusive)")
  }

  // workspace
  if (exp.workspace) {
    if (!check.object(exp.workspace)) throw Error("workspace must be an object")
    if (!check.array.of.string(exp.workspace.links)) throw Error("Workspace must have links field as an array of strings")
  }

  // trials
  if (exp.trials) {
    if (!check.number(exp.trials)) throw Error("Trials must be a number")
  }

  // wall
  if (!check.string(exp.wall)) throw Error("wall must be a string")

  // raw flags
  if (exp.raw) {
    if (!check.object(exp.raw)) throw Error("raw field must be an object")

    if (!exp.raw.headers && !exp.raw.runFlags) throw Error("raw field must have a headers or runFlags subfield")

    // raw headers
    if (exp.raw.headers) {
      if (!check.array.of.string(exp.raw.headers)) throw Error("Raw headers must be an array of strings")
    }

    // runFlags
    if (exp.raw.runFlags) {
      if (!check.array.of.string(exp.raw.runFlags)) throw Error("Raw runFlags must be an array of strings")
    }

function generateHtmlElement(rootModule, options) {
	// var headElement =
	var p = generateHeadElement(options);
	lazyAss(check.object(p), 'received a promise object');

	return p.then(function (headElement) {
		var framework = options.framework || 'qunit';
		verify.string(framework, 'missing framework string ' + framework);

		var doc = {
			index: [],
			docs: []
		};
		docModule(rootModule, doc, framework);

		var indexElement = html.div('#index', doc.index);

		var repoUrl = 'https://github.com/bahmutov/xplain';
		var repoHref = html.a({
			href: repoUrl

return p.then(function (result) {
      lazyAss(check.object(result), 'has result');
      lazyAss(check.object(result.inputOptions), 'has input options');
      lazyAss(check.array(result.inputFiles), 'has input files');
      lazyAss(result.inputFiles.length === 1,
        'should have single inputfile', result);
      lazyAss(result.inputOptions.framework === 'jasmine',
        'should be jasmine', result);
    }).done();
  });

function transform(code, framework) {
    verify.string(code, 'missing code to parse');
    verify.string(framework, 'missing framework');

    var humanForm = parseUnitTestCode(code, framework);
    verify.object(humanForm, 'could not convert to human form', code);

    if (!check.string(humanForm.code)) {
        console.log('could not convert', code, 'to human form');
        humanForm.code = code;
    }

    humanForm.code.trim();
    return humanForm;
}

function processDependencies (node, syntax, clearDependencies) {
    var dependencies;

    if (check.function(syntax.dependencies)) {
        dependencies = syntax.dependencies(node, clearDependencies);
        if (check.object(dependencies) || check.array(dependencies)) {
            report.dependencies = report.dependencies.concat(dependencies);
        }

        return true;
    }

    return false;
}

function createFunctionReport (name, lines, params) {
    var result = {
        name: name,
        sloc: {
            logical: 0
        },
        cyclomatic: 1,
        halstead: createInitialHalsteadState(),
        params: params
    };

    if (check.object(lines)) {
        result.line = lines.start.line;
        result.sloc.physical = lines.end.line - lines.start.line + 1;
    }

    return result;
}

checkObject (obj) {
    return check.object(obj)
  }