JavaScript-Embedded
view release on metacpan or search on metacpan
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
/* coercion order matters */
h_v = duk_to_hstring_acceptsymbol(thr, 0);
DUK_ASSERT(h_v != NULL);
h_obj = duk_push_this_coercible_to_object(thr);
DUK_ASSERT(h_obj != NULL);
ret = duk_hobject_get_own_propdesc(thr, h_obj, h_v, &desc, 0 /*flags*/); /* don't push value */
duk_push_boolean(thr, ret && ((desc.flags & required_desc_flags) == required_desc_flags));
return 1;
}
/*
* Object.seal() and Object.freeze() (E5 Sections 15.2.3.8 and 15.2.3.9)
*
* Since the algorithms are similar, a helper provides both functions.
* Freezing is essentially sealing + making plain properties non-writable.
*
* Note: virtual (non-concrete) properties which are non-configurable but
t/data/typescript.js view on Meta::CPAN
exit: function (exitCode) {
try {
WScript.Quit(exitCode);
}
catch (e) {
}
}
};
}
function getNodeSystem() {
var _fs = require("fs");
var _path = require("path");
var _os = require("os");
// average async stat takes about 30 microseconds
// set chunk size to do 30 files in < 1 millisecond
function createPollingWatchedFileSet(interval, chunkSize) {
if (interval === void 0) { interval = 2500; }
if (chunkSize === void 0) { chunkSize = 30; }
var watchedFiles = [];
var nextFileToCheck = 0;
var watchTimer;
function getModifiedTime(fileName) {
return _fs.statSync(fileName).mtime;
t/data/typescript.js view on Meta::CPAN
return nextToken() === 39 /* SlashToken */;
}
function parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers) {
parseExpected(89 /* ImportKeyword */);
var afterImportPos = scanner.getStartPos();
var identifier;
if (isIdentifier()) {
identifier = parseIdentifier();
if (token !== 24 /* CommaToken */ && token !== 133 /* FromKeyword */) {
// ImportEquals declaration of type:
// import x = require("mod"); or
// import x = M.x;
var importEqualsDeclaration = createNode(224 /* ImportEqualsDeclaration */, fullStart);
importEqualsDeclaration.decorators = decorators;
setModifiers(importEqualsDeclaration, modifiers);
importEqualsDeclaration.name = identifier;
parseExpected(56 /* EqualsToken */);
importEqualsDeclaration.moduleReference = parseModuleReference();
parseSemicolon();
return finishNode(importEqualsDeclaration);
}
t/data/typescript.js view on Meta::CPAN
nodeToCheck = declaration;
}
var moduleElementEmitInfo = ts.forEach(moduleElementDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined; });
if (!moduleElementEmitInfo && asynchronousSubModuleDeclarationEmitInfo) {
moduleElementEmitInfo = ts.forEach(asynchronousSubModuleDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined; });
}
// If the alias was marked as not visible when we saw its declaration, we would have saved the aliasEmitInfo, but if we haven't yet visited the alias declaration
// then we don't need to write it at this point. We will write it when we actually see its declaration
// Eg.
// export function bar(a: foo.Foo) { }
// import foo = require("foo");
// Writing of function bar would mark alias declaration foo as visible but we haven't yet visited that declaration so do nothing,
// we would write alias foo declaration when we visit it since it would now be marked as visible
if (moduleElementEmitInfo) {
if (moduleElementEmitInfo.node.kind === 225 /* ImportDeclaration */) {
// we have to create asynchronous output only after we have collected complete information
// because it is possible to enable multiple bindings as asynchronously visible
moduleElementEmitInfo.isVisible = true;
}
else {
createAndSetNewTextWriterWithSymbolWriter();
t/data/typescript.js view on Meta::CPAN
}
function emitExternalImportDeclaration(node) {
if (ts.contains(externalImports, node)) {
var isExportedImport = node.kind === 224 /* ImportEqualsDeclaration */ && (node.flags & 2 /* Export */) !== 0;
var namespaceDeclaration = getNamespaceDeclarationNode(node);
var varOrConst = (languageVersion <= 1 /* ES5 */) ? "var " : "const ";
if (modulekind !== 2 /* AMD */) {
emitLeadingComments(node);
emitStart(node);
if (namespaceDeclaration && !isDefaultImport(node)) {
// import x = require("foo")
// import * as x from "foo"
if (!isExportedImport) {
write(varOrConst);
}
;
emitModuleMemberName(namespaceDeclaration);
write(" = ");
}
else {
// import "foo"
t/data/typescript.js view on Meta::CPAN
resolver.isReferencedAliasDeclaration(node.importClause, /*checkChildren*/ true)) {
// import "mod"
// import x from "mod" where x is referenced
// import * as x from "mod" where x is referenced
// import { x, y } from "mod" where at least one import is referenced
externalImports.push(node);
}
break;
case 224 /* ImportEqualsDeclaration */:
if (node.moduleReference.kind === 235 /* ExternalModuleReference */ && resolver.isReferencedAliasDeclaration(node)) {
// import x = require("mod") where x is referenced
externalImports.push(node);
}
break;
case 231 /* ExportDeclaration */:
if (node.moduleSpecifier) {
if (!node.exportClause) {
// export * from "mod"
if (resolver.moduleExportsSomeValue(node.moduleSpecifier)) {
externalImports.push(node);
hasExportStarsToExportValues = true;
t/data/typescript.js view on Meta::CPAN
}
function processImports() {
scanner.setText(sourceText);
scanner.scan();
// Look for:
// import "mod";
// import d from "mod"
// import {a as A } from "mod";
// import * as NS from "mod"
// import d, {a, b as B} from "mod"
// import i = require("mod");
//
// export * from "mod"
// export {a as b} from "mod"
// export import i = require("mod")
// (for JavaScript files) require("mod")
while (true) {
if (scanner.getToken() === 1 /* EndOfFileToken */) {
break;
}
// check if at least one of alternative have moved scanner forward
if (tryConsumeDeclare() ||
tryConsumeImport() ||
tryConsumeExport() ||
(detectJavaScriptImports && (tryConsumeRequireCall(/*skipCurrentToken*/ false) || tryConsumeDefine()))) {
t/data/typescript.js view on Meta::CPAN
walk(sourceFile);
sourceFile.nameTable = nameTable;
function walk(node) {
switch (node.kind) {
case 69 /* Identifier */:
nameTable[node.text] = nameTable[node.text] === undefined ? node.pos : -1;
break;
case 9 /* StringLiteral */:
case 8 /* NumericLiteral */:
// We want to store any numbers/strings if they were a name that could be
// related to a declaration. So, if we have 'import x = require("something")'
// then we want 'something' to be in the name table. Similarly, if we have
// "a['propname']" then we want to store "propname" in the name table.
if (ts.isDeclarationName(node) ||
node.parent.kind === 235 /* ExternalModuleReference */ ||
isArgumentOfElementAccessExpression(node)) {
nameTable[node.text] = nameTable[node.text] === undefined ? node.pos : -1;
}
break;
default:
ts.forEachChild(node, walk);
t/typescript.t view on Meta::CPAN
$js->eval(q{
var module = {};
var exports = module.exports = {};
function require(){
eval(load());
return module.exports;
}
});
my $ts = $js->eval(q{
var ts = require('ts');
ts;
});
is ref( $ts->{transpile} ), 'CODE';
};
subtest 'typescript transpile' => sub {
my $js = JavaScript::Embedded->new;
$js->set( load => sub { _load_ts(); } );
t/typescript.t view on Meta::CPAN
$js->eval(q{
var module = {};
var exports = module.exports = {};
function require(){
eval(load());
return module.exports;
}
});
my $code = $js->eval(q{
var ts = require('ts');
var code = ts.transpile('class Foo { bar: string; constructor(){ this.bar="baz" }; };');
code;
});
like $code, qr/Foo.*function/;
my $ret = $js->eval( $code . "; (new Foo()).bar" );
is $ret, 'baz';
};
( run in 0.563 second using v1.01-cache-2.11-cpan-0d8aa00de5b )