New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

kecubung

Package Overview
Dependencies
Maintainers
1
Versions
67
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

kecubung - npm Package Compare versions

Comparing version 0.5.0-alpha.695401af to 0.5.0-alpha.70d3c872

45

lib/analyzers/astree/child-decorator-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const H = require("./helper");
class ChildDecoratorAnalyzer {
constructor(node) {
var H = require("./helper");
var ChildDecoratorAnalyzer = /** @class */ (function () {
function ChildDecoratorAnalyzer(node) {
this.node = node;
}
isMethodDecorator() {
ChildDecoratorAnalyzer.prototype.isMethodDecorator = function () {
return !H.isReservedDecorator(this.node);
}
isParameterDecorator() {
};
ChildDecoratorAnalyzer.prototype.isParameterDecorator = function () {
return H.getMethodNameFromCallee(this.node.callee) == "__param";
}
getMethodName() {
};
ChildDecoratorAnalyzer.prototype.getMethodName = function () {
return H.getMethodNameFromCallee(this.node.callee);
}
getMethodLocation() {
};
ChildDecoratorAnalyzer.prototype.getMethodLocation = function () {
return {

@@ -22,10 +22,10 @@ start: this.node.start,

};
}
getMethodParameters() {
return this.node.arguments.map((x) => H.getDecoratorParameterName(x));
}
getParameterDecoratorName() {
};
ChildDecoratorAnalyzer.prototype.getMethodParameters = function () {
return this.node.arguments.map(function (x) { return H.getDecoratorParameterName(x); });
};
ChildDecoratorAnalyzer.prototype.getParameterDecoratorName = function () {
return H.getMethodNameFromCallee(this.node.arguments[1].callee);
}
getParameterDecoratorLocation() {
};
ChildDecoratorAnalyzer.prototype.getParameterDecoratorLocation = function () {
return {

@@ -35,8 +35,9 @@ start: this.node.start,

};
}
getParameterDecoratorParameters() {
};
ChildDecoratorAnalyzer.prototype.getParameterDecoratorParameters = function () {
return this.node.arguments[1].arguments
.map((x) => H.getDecoratorParameterName(x));
}
}
.map(function (x) { return H.getDecoratorParameterName(x); });
};
return ChildDecoratorAnalyzer;
}());
exports.ChildDecoratorAnalyzer = ChildDecoratorAnalyzer;

41

lib/analyzers/astree/class-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("../../core");
class ClassAnalyzer {
var core_1 = require("../../core");
var ClassAnalyzer = /** @class */ (function () {
/**
* expect VariableDeclaration, ExpressionStatement
*/
constructor(node) {
function ClassAnalyzer(node) {
this.node = node;

@@ -14,8 +14,8 @@ }

*/
isExported(name, parentName) {
ClassAnalyzer.prototype.isExported = function (name, parentName) {
return this.isExportedStatement()
&& (this.node.expression.left.object.name == parentName || this.node.expression.left.object.name == "exports")
&& this.node.expression.right.name == name;
}
getLocation() {
};
ClassAnalyzer.prototype.getLocation = function () {
return {

@@ -25,11 +25,11 @@ start: this.node.start,

};
}
};
//constructors & methods
getMember() {
ClassAnalyzer.prototype.getMember = function () {
return this.node.declarations[0].init.callee.body.body;
}
};
/**
* expect ExpressionStatement
*/
isExportedStatement() {
ClassAnalyzer.prototype.isExportedStatement = function () {
return this.node.type == core_1.SyntaxKind.ExpressionStatement

@@ -39,4 +39,4 @@ && this.node.expression.type == core_1.SyntaxKind.AssignmentExpression

&& this.node.expression.right.type == core_1.SyntaxKind.Identifier;
}
getName() {
};
ClassAnalyzer.prototype.getName = function () {
if (this.isExportedStatement())

@@ -48,4 +48,4 @@ return this.node.expression.right.name;

return null;
}
getParentName() {
};
ClassAnalyzer.prototype.getParentName = function () {
if (this.isExportedStatement())

@@ -55,4 +55,4 @@ return this.node.expression.left.object.name;

return null;
}
isCandidate() {
};
ClassAnalyzer.prototype.isCandidate = function () {
return this.node.type == core_1.SyntaxKind.VariableDeclaration

@@ -65,4 +65,4 @@ && this.node.declarations[0].type == core_1.SyntaxKind.VariableDeclarator

&& this.node.declarations[0].init.callee.id == null;
}
getBaseClass() {
};
ClassAnalyzer.prototype.getBaseClass = function () {
if (this.isCandidate() && this.node.declarations[0].init.arguments.length > 0) {

@@ -75,4 +75,5 @@ if (this.node.declarations[0].init.arguments[0].type == core_1.SyntaxKind.MemberExpression)

return null;
}
}
};
return ClassAnalyzer;
}());
exports.ClassAnalyzer = ClassAnalyzer;

25

lib/analyzers/astree/constructor-analyser.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Core = require("../../core");
class ConstructorAnalyzer {
constructor(node) {
var Core = require("../../core");
var ConstructorAnalyzer = /** @class */ (function () {
function ConstructorAnalyzer(node) {
this.node = node;
}
isConstructor(className) {
ConstructorAnalyzer.prototype.isConstructor = function (className) {
return this.node.type == Core.SyntaxKind.FunctionDeclaration
&& this.node.id.name == className;
}
getName() {
};
ConstructorAnalyzer.prototype.getName = function () {
return this.node.id.name;
}
getLocation() {
};
ConstructorAnalyzer.prototype.getLocation = function () {
return {

@@ -20,7 +20,8 @@ start: this.node.start,

};
}
getParameters() {
};
ConstructorAnalyzer.prototype.getParameters = function () {
return this.node.params;
}
}
};
return ConstructorAnalyzer;
}());
exports.ConstructorAnalyzer = ConstructorAnalyzer;

35

lib/analyzers/astree/decorator-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("../../core");
const HP = require("./helper");
class DecoratorAnalyzer {
constructor(node) {
var core_1 = require("../../core");
var HP = require("./helper");
var DecoratorAnalyzer = /** @class */ (function () {
function DecoratorAnalyzer(node) {
this.node = node;
}
isMethodDecorator() {
DecoratorAnalyzer.prototype.isMethodDecorator = function () {
return this.node.type == core_1.SyntaxKind.ExpressionStatement

@@ -14,4 +14,4 @@ && HP.getMethodNameFromCallee(this.node.expression.callee) == "__decorate"

&& this.node.expression.arguments[3].type == core_1.SyntaxKind.NullLiteral;
}
isPropertyDecorator() {
};
DecoratorAnalyzer.prototype.isPropertyDecorator = function () {
return this.node.type == core_1.SyntaxKind.ExpressionStatement

@@ -21,4 +21,4 @@ && HP.getMethodNameFromCallee(this.node.expression.callee) == "__decorate"

&& this.node.expression.arguments[3].type == core_1.SyntaxKind.UnaryExpression;
}
getClassName() {
};
DecoratorAnalyzer.prototype.getClassName = function () {
if (this.isMethodDecorator() || this.isPropertyDecorator())

@@ -31,4 +31,4 @@ return this.node.expression.arguments[1].object.name;

return null;
}
getMethodName() {
};
DecoratorAnalyzer.prototype.getMethodName = function () {
if (this.isMethodDecorator() || this.isPropertyDecorator())

@@ -38,4 +38,4 @@ return this.node.expression.arguments[2].value;

return null;
}
getChildren() {
};
DecoratorAnalyzer.prototype.getChildren = function () {
if (this.isClassDecorator())

@@ -45,4 +45,4 @@ return this.node.expression.right.arguments[0].elements;

return this.node.expression.arguments[0].elements;
}
isClassDecorator() {
};
DecoratorAnalyzer.prototype.isClassDecorator = function () {
return this.node.type == core_1.SyntaxKind.ExpressionStatement

@@ -53,4 +53,5 @@ && this.node.expression.type == core_1.SyntaxKind.AssignmentExpression

&& HP.getMethodNameFromCallee(this.node.expression.right.callee) == "__decorate";
}
}
};
return DecoratorAnalyzer;
}());
exports.DecoratorAnalyzer = DecoratorAnalyzer;

47

lib/analyzers/astree/es6-class-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("../../core");
const class_analyzer_1 = require("./class-analyzer");
class Es6ClassAnalyzer extends class_analyzer_1.ClassAnalyzer {
var tslib_1 = require("tslib");
var core_1 = require("../../core");
var class_analyzer_1 = require("./class-analyzer");
var Es6ClassAnalyzer = /** @class */ (function (_super) {
tslib_1.__extends(Es6ClassAnalyzer, _super);
/**
* expect VariableDeclaration, ExpressionStatement
*/
constructor(node) { super(node); }
function Es6ClassAnalyzer(node) {
return _super.call(this, node) || this;
}
//constructors & methods
getMember() {
Es6ClassAnalyzer.prototype.getMember = function () {
if (this.isClass())

@@ -16,4 +20,4 @@ return this.node.body.body;

return this.node.declarations[0].init.body.body;
}
getName() {
};
Es6ClassAnalyzer.prototype.getName = function () {
if (this.isClass())

@@ -23,15 +27,15 @@ return this.node.id.name;

return this.node.declarations[0].init.id.name;
}
isClass() {
};
Es6ClassAnalyzer.prototype.isClass = function () {
return this.node.type == core_1.SyntaxKind.ClassDeclaration;
}
isVariableDeclaration() {
};
Es6ClassAnalyzer.prototype.isVariableDeclaration = function () {
return this.node.type == core_1.SyntaxKind.VariableDeclaration &&
this.node.declarations[0].init &&
this.node.declarations[0].init.type == core_1.SyntaxKind.ClassExpression;
}
isCandidate() {
};
Es6ClassAnalyzer.prototype.isCandidate = function () {
return this.isClass() || this.isVariableDeclaration();
}
getBaseClassSimple() {
};
Es6ClassAnalyzer.prototype.getBaseClassSimple = function () {
if (!this.node.superClass)

@@ -43,4 +47,4 @@ return;

return this.node.superClass.name;
}
getBaseClassWithDeclaration() {
};
Es6ClassAnalyzer.prototype.getBaseClassWithDeclaration = function () {
if (!this.node.declarations[0].init.superClass)

@@ -52,4 +56,4 @@ return;

return this.node.declarations[0].init.superClass.name;
}
getBaseClass() {
};
Es6ClassAnalyzer.prototype.getBaseClass = function () {
if (this.isClass())

@@ -59,4 +63,5 @@ return this.getBaseClassSimple();

return this.getBaseClassWithDeclaration();
}
}
};
return Es6ClassAnalyzer;
}(class_analyzer_1.ClassAnalyzer));
exports.Es6ClassAnalyzer = Es6ClassAnalyzer;

29

lib/analyzers/astree/es6-member-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("../../core");
class Es6MemberAnalyzer {
constructor(node) {
var core_1 = require("../../core");
var Es6MemberAnalyzer = /** @class */ (function () {
function Es6MemberAnalyzer(node) {
this.node = node;
}
getParameters() {
Es6MemberAnalyzer.prototype.getParameters = function () {
return this.node.params;
}
getType() {
};
Es6MemberAnalyzer.prototype.getType = function () {
switch (this.node.kind) {

@@ -18,10 +18,10 @@ case "constructor":

}
}
getName() {
};
Es6MemberAnalyzer.prototype.getName = function () {
return this.node.key.name;
}
isCandidate() {
};
Es6MemberAnalyzer.prototype.isCandidate = function () {
return this.node.type == core_1.SyntaxKind.ClassMethod;
}
getLocation() {
};
Es6MemberAnalyzer.prototype.getLocation = function () {
return {

@@ -31,4 +31,5 @@ start: this.node.start,

};
}
}
};
return Es6MemberAnalyzer;
}());
exports.Es6MemberAnalyzer = Es6MemberAnalyzer;

15

lib/analyzers/astree/file-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class FileAnalyzer {
constructor(node) {
var FileAnalyzer = /** @class */ (function () {
function FileAnalyzer(node) {
this.node = node;
}
getChildren() {
FileAnalyzer.prototype.getChildren = function () {
return this.node.program.body;
}
getLocation() {
};
FileAnalyzer.prototype.getLocation = function () {
return {

@@ -15,4 +15,5 @@ start: this.node.start,

};
}
}
};
return FileAnalyzer;
}());
exports.FileAnalyzer = FileAnalyzer;

14

lib/analyzers/astree/helper.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("../../core");
var core_1 = require("../../core");
/**

@@ -53,7 +53,8 @@ * require CallExpression.callee

function getArrayParameter(param) {
let result = {
var result = {
type: "Array",
children: []
};
for (let item of param.elements) {
for (var _i = 0, _a = param.elements; _i < _a.length; _i++) {
var item = _a[_i];
result.children.push(getDecoratorParameterName(item));

@@ -64,3 +65,3 @@ }

function getPropertyParameter(param) {
let value = getDecoratorParameterName(param.value);
var value = getDecoratorParameterName(param.value);
return {

@@ -73,7 +74,8 @@ type: value.type,

function getObjectParameter(param) {
let result = {
var result = {
type: "Object",
properties: []
};
for (let item of param.properties) {
for (var _i = 0, _a = param.properties; _i < _a.length; _i++) {
var item = _a[_i];
result.properties.push(getPropertyParameter(item));

@@ -80,0 +82,0 @@ }

22

lib/analyzers/astree/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const baseclasses_1 = require("../baseclasses");
const child_decorator_analyzer_1 = require("./child-decorator-analyzer");
var baseclasses_1 = require("../baseclasses");
var child_decorator_analyzer_1 = require("./child-decorator-analyzer");
exports.ChildDecoratorAnalyzer = child_decorator_analyzer_1.ChildDecoratorAnalyzer;
const class_analyzer_1 = require("./class-analyzer");
var class_analyzer_1 = require("./class-analyzer");
exports.ClassAnalyzer = class_analyzer_1.ClassAnalyzer;
const constructor_analyser_1 = require("./constructor-analyser");
var constructor_analyser_1 = require("./constructor-analyser");
exports.ConstructorAnalyzer = constructor_analyser_1.ConstructorAnalyzer;
const decorator_analyzer_1 = require("./decorator-analyzer");
var decorator_analyzer_1 = require("./decorator-analyzer");
exports.DecoratorAnalyzer = decorator_analyzer_1.DecoratorAnalyzer;
const file_analyzer_1 = require("./file-analyzer");
var file_analyzer_1 = require("./file-analyzer");
exports.FileAnalyzer = file_analyzer_1.FileAnalyzer;
const method_analyzer_1 = require("./method-analyzer");
var method_analyzer_1 = require("./method-analyzer");
exports.MethodAnalyzer = method_analyzer_1.MethodAnalyzer;
const module_analyzer_1 = require("./module-analyzer");
var module_analyzer_1 = require("./module-analyzer");
exports.ModuleAnalyzer = module_analyzer_1.ModuleAnalyzer;
const parameter_analyzer_1 = require("./parameter-analyzer");
var parameter_analyzer_1 = require("./parameter-analyzer");
exports.ParameterAnalyzer = parameter_analyzer_1.ParameterAnalyzer;
const es6_class_analyzer_1 = require("./es6-class-analyzer");
var es6_class_analyzer_1 = require("./es6-class-analyzer");
exports.Es6ClassAnalyzer = es6_class_analyzer_1.Es6ClassAnalyzer;
const es6_member_analyzer_1 = require("./es6-member-analyzer");
var es6_member_analyzer_1 = require("./es6-member-analyzer");
exports.Es6MemberAnalyzer = es6_member_analyzer_1.Es6MemberAnalyzer;

@@ -24,0 +24,0 @@ function get(type, node) {

39

lib/analyzers/astree/method-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("../../core");
class MethodAnalyzer {
var core_1 = require("../../core");
var MethodAnalyzer = /** @class */ (function () {
/**
* expect ExpressionStatement
*/
constructor(node) {
function MethodAnalyzer(node) {
this.node = node;
}
isMethod(className) {
MethodAnalyzer.prototype.isMethod = function (className) {
return this.isMethodStatement()
&& this.node.expression.left.object.object.name == className;
}
isMethodStatement() {
};
MethodAnalyzer.prototype.isMethodStatement = function () {
return this.node.type == core_1.SyntaxKind.ExpressionStatement

@@ -22,4 +22,4 @@ && this.node.expression.type == core_1.SyntaxKind.AssignmentExpression

&& this.node.expression.right.type == core_1.SyntaxKind.FunctionExpression;
}
getName() {
};
MethodAnalyzer.prototype.getName = function () {
if (this.isMethodStatement())

@@ -29,4 +29,4 @@ return this.node.expression.left.property.name;

return null;
}
getClassName() {
};
MethodAnalyzer.prototype.getClassName = function () {
if (this.isMethodStatement())

@@ -36,4 +36,4 @@ return this.node.expression.left.object.object.name;

return null;
}
getLocation() {
};
MethodAnalyzer.prototype.getLocation = function () {
return {

@@ -43,13 +43,14 @@ start: this.node.start,

};
}
getParameters() {
};
MethodAnalyzer.prototype.getParameters = function () {
return this.node.expression.right.params;
}
getParams() {
};
MethodAnalyzer.prototype.getParams = function () {
if (this.isMethodStatement())
return this.node.expression.right.params.map((x) => x.name);
return this.node.expression.right.params.map(function (x) { return x.name; });
else
return null;
}
}
};
return MethodAnalyzer;
}());
exports.MethodAnalyzer = MethodAnalyzer;

29

lib/analyzers/astree/module-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("../../core");
class ModuleAnalyzer {
var core_1 = require("../../core");
var ModuleAnalyzer = /** @class */ (function () {
/**
* require ExpressionStatement
*/
constructor(node) {
function ModuleAnalyzer(node) {
this.node = node;
}
isCandidate() {
ModuleAnalyzer.prototype.isCandidate = function () {
/*

@@ -23,7 +23,7 @@ (function(ModuleName){})(ModuleName = (<any>.ModuleName) || ())

&& this.node.expression.arguments[0].left.name == this.node.expression.callee.params[0].name;
}
getBody() {
};
ModuleAnalyzer.prototype.getBody = function () {
return this.node.expression.callee.body.body;
}
getName() {
};
ModuleAnalyzer.prototype.getName = function () {
if (this.isCandidate())

@@ -33,4 +33,4 @@ return this.node.expression.arguments[0].left.name;

return null;
}
getLocation() {
};
ModuleAnalyzer.prototype.getLocation = function () {
return {

@@ -40,4 +40,4 @@ start: this.node.start,

};
}
isExported(parentName) {
};
ModuleAnalyzer.prototype.isExported = function (parentName) {
//(function(Children){})(Children = (Parent.Children) || ())

@@ -50,4 +50,5 @@ //(function(Children){})(Children = (exports.Children) || ())

|| this.node.expression.arguments[0].right.left.object.name == "exports");
}
}
};
return ModuleAnalyzer;
}());
exports.ModuleAnalyzer = ModuleAnalyzer;

21

lib/analyzers/astree/parameter-analyzer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("../../core");
class ParameterAnalyzer {
constructor(node) {
var core_1 = require("../../core");
var ParameterAnalyzer = /** @class */ (function () {
function ParameterAnalyzer(node) {
this.node = node;
}
withDefaultValue() {
ParameterAnalyzer.prototype.withDefaultValue = function () {
return this.node.type == core_1.SyntaxKind.AssignmentPattern;
}
getName() {
};
ParameterAnalyzer.prototype.getName = function () {
if (this.withDefaultValue())

@@ -16,4 +16,4 @@ return this.node.left.name;

return this.node.name;
}
getLocation() {
};
ParameterAnalyzer.prototype.getLocation = function () {
return {

@@ -23,4 +23,5 @@ start: this.node.start,

};
}
}
};
return ParameterAnalyzer;
}());
exports.ParameterAnalyzer = ParameterAnalyzer;

2

lib/analyzers/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const AsTree = require("./astree");
var AsTree = require("./astree");
function get(parser, type, node) {

@@ -5,0 +5,0 @@ return AsTree.get(type, node);

39

lib/core.js

@@ -49,3 +49,3 @@ "use strict";

(function (Call) {
const META_DATA_KEY = "kamboja:Call.when";
var META_DATA_KEY = "kamboja:Call.when";
function when(kind) {

@@ -58,3 +58,3 @@ return function (target, method, descriptor) {

function getWhen(target, methodName) {
let result = Reflect.getMetadata(META_DATA_KEY, target, methodName);
var result = Reflect.getMetadata(META_DATA_KEY, target, methodName);
if (typeof result == "undefined")

@@ -66,22 +66,31 @@ throw new Error("Unable to get metadata identifier, try to re-install refrect-metadata module");

})(Call = exports.Call || (exports.Call = {}));
class TransformerBase {
traverse(children, metaData, transformers) {
let calls = this.getCalls(transformers);
for (let child of children) {
if (calls.some(x => x == child.type)) {
for (let transformer of transformers) {
var TransformerBase = /** @class */ (function () {
function TransformerBase() {
}
TransformerBase.prototype.traverse = function (children, metaData, transformers) {
var calls = this.getCalls(transformers);
var _loop_1 = function (child) {
if (calls.some(function (x) { return x == child.type; })) {
for (var _i = 0, transformers_1 = transformers; _i < transformers_1.length; _i++) {
var transformer = transformers_1[_i];
transformer.transform(child, metaData);
}
}
};
for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
var child = children_1[_i];
_loop_1(child);
}
}
getCalls(traversers) {
let calls = [];
for (let traverser of traversers) {
let cal = Call.getWhen(traverser, "transform");
};
TransformerBase.prototype.getCalls = function (traversers) {
var calls = [];
for (var _i = 0, traversers_1 = traversers; _i < traversers_1.length; _i++) {
var traverser = traversers_1[_i];
var cal = Call.getWhen(traverser, "transform");
calls.push(cal);
}
return calls;
}
}
};
return TransformerBase;
}());
exports.TransformerBase = TransformerBase;

4

lib/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const transformer_1 = require("./transformer");
var transformer_1 = require("./transformer");
var core_1 = require("./core");

@@ -10,5 +10,5 @@ exports.AnalysisType = core_1.AnalysisType;

function transform(parser, ast, fileName) {
let transformer = new transformer_1.Transformer(fileName, parser);
var transformer = new transformer_1.Transformer(fileName, parser);
return transformer.transform(ast);
}
exports.transform = transform;

51

lib/transformer.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Analyzer = require("./analyzers");
const core_1 = require("./core");
const ts_class_1 = require("./transformers/ts-class");
const ts_module_1 = require("./transformers/ts-module");
const ts_decorator_1 = require("./transformers/ts-decorator");
const ts_class_export_1 = require("./transformers/ts-class-export");
const es6_class_1 = require("./transformers/es6-class");
class Transformer {
constructor(fileName, parser) {
var tslib_1 = require("tslib");
var Analyzer = require("./analyzers");
var core_1 = require("./core");
var ts_class_1 = require("./transformers/ts-class");
var ts_module_1 = require("./transformers/ts-module");
var ts_decorator_1 = require("./transformers/ts-decorator");
var ts_class_export_1 = require("./transformers/ts-class-export");
var es6_class_1 = require("./transformers/es6-class");
var Transformer = /** @class */ (function () {
function Transformer(fileName, parser) {
this.fileName = fileName;
this.parser = parser;
}
transform(ast) {
let analyzer = Analyzer
Transformer.prototype.transform = function (ast) {
var analyzer = Analyzer
.get(this.parser, Analyzer.AnalyzerType.File, ast);
let file = {
var file = {
type: "File",

@@ -25,15 +26,18 @@ name: this.fileName,

};
let fileTransformer = new FileTransformer(this.parser);
var fileTransformer = new FileTransformer(this.parser);
fileTransformer.transform(ast, file);
return file;
}
}
};
return Transformer;
}());
exports.Transformer = Transformer;
class FileTransformer extends core_1.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var FileTransformer = /** @class */ (function (_super) {
tslib_1.__extends(FileTransformer, _super);
function FileTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzer = Analyzer
FileTransformer.prototype.transform = function (node, parent) {
var analyzer = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.File, node);

@@ -47,3 +51,4 @@ this.traverse(analyzer.getChildren(), parent, [

]);
}
}
};
return FileTransformer;
}(core_1.TransformerBase));

35

lib/transformers/constructor.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const parameter_1 = require("./parameter");
const Core = require("../core");
class ConstructorTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var parameter_1 = require("./parameter");
var Core = require("../core");
var ConstructorTransformer = /** @class */ (function (_super) {
tslib_1.__extends(ConstructorTransformer, _super);
function ConstructorTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyser = Analyzer
ConstructorTransformer.prototype.transform = function (node, parent) {
var analyser = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.Constructor, node);
if (analyser.isConstructor(parent.name)) {
let constructor = {
var constructor = {
type: "Constructor",

@@ -28,7 +30,8 @@ name: analyser.getName(),

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.FunctionDeclaration)
], ConstructorTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.FunctionDeclaration)
], ConstructorTransformer.prototype, "transform", null);
return ConstructorTransformer;
}(Core.TransformerBase));
exports.ConstructorTransformer = ConstructorTransformer;

39

lib/transformers/es6-class-member.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const parameter_1 = require("./parameter");
const parameter_with_default_1 = require("./parameter-with-default");
const Core = require("../core");
class Es6ClassMember extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var parameter_1 = require("./parameter");
var parameter_with_default_1 = require("./parameter-with-default");
var Core = require("../core");
var Es6ClassMember = /** @class */ (function (_super) {
tslib_1.__extends(Es6ClassMember, _super);
function Es6ClassMember(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyser = Analyzer
Es6ClassMember.prototype.transform = function (node, parent) {
var analyser = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.Es6ClassMember, node);
let type = analyser.getType();
var type = analyser.getType();
if (analyser.isCandidate()) {
let method = {
var method = {
type: type,

@@ -36,7 +38,8 @@ name: analyser.getName(),

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ClassMethod)
], Es6ClassMember.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ClassMethod)
], Es6ClassMember.prototype, "transform", null);
return Es6ClassMember;
}(Core.TransformerBase));
exports.Es6ClassMember = Es6ClassMember;

41

lib/transformers/es6-class.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const es6_class_member_1 = require("./es6-class-member");
const Core = require("../core");
class Es6ClassTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var es6_class_member_1 = require("./es6-class-member");
var Core = require("../core");
var Es6ClassTransformer = /** @class */ (function (_super) {
tslib_1.__extends(Es6ClassTransformer, _super);
function Es6ClassTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzer = Analyzer
Es6ClassTransformer.prototype.transform = function (node, parent) {
var analyzer = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.Es6Class, node);
if (analyzer.isCandidate()) {
let clazz = {
var clazz = {
type: "Class",

@@ -29,4 +31,4 @@ name: analyzer.getName(),

}
}
analyse(clazz, parent, analyzer) {
};
Es6ClassTransformer.prototype.analyse = function (clazz, parent, analyzer) {
/*

@@ -37,10 +39,11 @@ TS class is not valid *YET* here,

clazz.analysis |= Core.AnalysisType.HasConstructor;
let hasMethods = clazz.methods && clazz.methods.length > 0;
var hasMethods = clazz.methods && clazz.methods.length > 0;
if (hasMethods)
clazz.analysis |= Core.AnalysisType.HasMethod;
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ClassDeclaration)
], Es6ClassTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ClassDeclaration)
], Es6ClassTransformer.prototype, "transform", null);
return Es6ClassTransformer;
}(Core.TransformerBase));
exports.Es6ClassTransformer = Es6ClassTransformer;

35

lib/transformers/method.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const parameter_1 = require("./parameter");
const Core = require("../core");
class MethodTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var parameter_1 = require("./parameter");
var Core = require("../core");
var MethodTransformer = /** @class */ (function (_super) {
tslib_1.__extends(MethodTransformer, _super);
function MethodTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyser = Analyzer
MethodTransformer.prototype.transform = function (node, parent) {
var analyser = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.Method, node);
if (analyser.isMethod(parent.name)) {
let method = {
var method = {
type: "Method",

@@ -30,7 +32,8 @@ name: analyser.getName(),

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ExpressionStatement)
], MethodTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ExpressionStatement)
], MethodTransformer.prototype, "transform", null);
return MethodTransformer;
}(Core.TransformerBase));
exports.MethodTransformer = MethodTransformer;

31

lib/transformers/parameter-with-default.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Core = require("../core");
const Analyzer = require("../analyzers");
class ParameterWithDefaultTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Core = require("../core");
var Analyzer = require("../analyzers");
var ParameterWithDefaultTransformer = /** @class */ (function (_super) {
tslib_1.__extends(ParameterWithDefaultTransformer, _super);
function ParameterWithDefaultTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzer = Analyzer
ParameterWithDefaultTransformer.prototype.transform = function (node, parent) {
var analyzer = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.Parameter, node);

@@ -22,7 +24,8 @@ if (!analyzer.withDefaultValue())

});
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.AssignmentPattern)
], ParameterWithDefaultTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.AssignmentPattern)
], ParameterWithDefaultTransformer.prototype, "transform", null);
return ParameterWithDefaultTransformer;
}(Core.TransformerBase));
exports.ParameterWithDefaultTransformer = ParameterWithDefaultTransformer;

31

lib/transformers/parameter.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Core = require("../core");
const Analyzer = require("../analyzers");
class ParameterTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Core = require("../core");
var Analyzer = require("../analyzers");
var ParameterTransformer = /** @class */ (function (_super) {
tslib_1.__extends(ParameterTransformer, _super);
function ParameterTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzer = Analyzer
ParameterTransformer.prototype.transform = function (node, parent) {
var analyzer = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.Parameter, node);

@@ -22,7 +24,8 @@ if (analyzer.withDefaultValue())

});
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.Identifier)
], ParameterTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.Identifier)
], ParameterTransformer.prototype, "transform", null);
return ParameterTransformer;
}(Core.TransformerBase));
exports.ParameterTransformer = ParameterTransformer;

45

lib/transformers/ts-child-decorator.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const Core = require("../core");
class TsChildDecoratorTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var Core = require("../core");
var TsChildDecoratorTransformer = /** @class */ (function (_super) {
tslib_1.__extends(TsChildDecoratorTransformer, _super);
function TsChildDecoratorTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzers = Analyzer
TsChildDecoratorTransformer.prototype.transform = function (node, parent) {
var analyzers = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.ChildDecorator, node);

@@ -20,8 +22,8 @@ if (analyzers.isMethodDecorator()) {

&& parent.parameters.length > 0) {
let parameter = parent.parameters[parseInt(node.arguments[0].value)];
var parameter = parent.parameters[parseInt(node.arguments[0].value)];
this.transformParameter(analyzers, parameter);
}
}
transformMethod(analyzer, parent) {
let method = {
};
TsChildDecoratorTransformer.prototype.transformMethod = function (analyzer, parent) {
var method = {
type: "Decorator",

@@ -36,5 +38,5 @@ name: analyzer.getMethodName(),

parent.decorators.push(method);
}
transformParameter(analyzer, parameter) {
let decorator = {
};
TsChildDecoratorTransformer.prototype.transformParameter = function (analyzer, parameter) {
var decorator = {
type: "Decorator",

@@ -49,7 +51,8 @@ name: analyzer.getParameterDecoratorName(),

parameter.decorators.push(decorator);
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.CallExpression)
], TsChildDecoratorTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.CallExpression)
], TsChildDecoratorTransformer.prototype, "transform", null);
return TsChildDecoratorTransformer;
}(Core.TransformerBase));
exports.TsChildDecoratorTransformer = TsChildDecoratorTransformer;

37

lib/transformers/ts-class-export.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const Core = require("../core");
class TsClassExporterTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var Core = require("../core");
var TsClassExporterTransformer = /** @class */ (function (_super) {
tslib_1.__extends(TsClassExporterTransformer, _super);
function TsClassExporterTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzer = Analyzer
TsClassExporterTransformer.prototype.transform = function (node, parent) {
var analyzer = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.TSClass, node);
let parentName = analyzer.getParentName();
let className = analyzer.getName();
let clazz = parent.children.filter(x => x.name == className)[0];
var parentName = analyzer.getParentName();
var className = analyzer.getName();
var clazz = parent.children.filter(function (x) { return x.name == className; })[0];
if (clazz && ((parent.type == "File" && parentName == "exports")

@@ -23,7 +25,8 @@ || (parent.type == "Module" && parentName == parent.name))) {

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ExpressionStatement)
], TsClassExporterTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ExpressionStatement)
], TsClassExporterTransformer.prototype, "transform", null);
return TsClassExporterTransformer;
}(Core.TransformerBase));
exports.TsClassExporterTransformer = TsClassExporterTransformer;

47

lib/transformers/ts-class.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const method_1 = require("./method");
const constructor_1 = require("./constructor");
const ts_decorator_1 = require("./ts-decorator");
const Core = require("../core");
class TsClassTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var method_1 = require("./method");
var constructor_1 = require("./constructor");
var ts_decorator_1 = require("./ts-decorator");
var Core = require("../core");
var TsClassTransformer = /** @class */ (function (_super) {
tslib_1.__extends(TsClassTransformer, _super);
function TsClassTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzer = Analyzer
TsClassTransformer.prototype.transform = function (node, parent) {
var analyzer = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.TSClass, node);
if (analyzer.isCandidate()) {
let clazz = {
var clazz = {
type: "Class",

@@ -33,4 +35,4 @@ name: analyzer.getName(),

}
}
analyse(clazz, parent, analyzer) {
};
TsClassTransformer.prototype.analyse = function (clazz, parent, analyzer) {
/*

@@ -40,4 +42,4 @@ TS class is not valid *YET* here,

*/
let hasConstructor = typeof clazz.constructor == "function" ? false : true;
let hasMethods = clazz.methods && clazz.methods.length > 0;
var hasConstructor = typeof clazz.constructor == "function" ? false : true;
var hasMethods = clazz.methods && clazz.methods.length > 0;
if (hasConstructor)

@@ -47,7 +49,8 @@ clazz.analysis |= Core.AnalysisType.HasConstructor;

clazz.analysis |= Core.AnalysisType.HasMethod;
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.VariableDeclaration)
], TsClassTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.VariableDeclaration)
], TsClassTransformer.prototype, "transform", null);
return TsClassTransformer;
}(Core.TransformerBase));
exports.TsClassTransformer = TsClassTransformer;

57

lib/transformers/ts-decorator.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const Core = require("../core");
const ts_child_decorator_1 = require("./ts-child-decorator");
class TsDecorator extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var Core = require("../core");
var ts_child_decorator_1 = require("./ts-child-decorator");
var TsDecorator = /** @class */ (function (_super) {
tslib_1.__extends(TsDecorator, _super);
function TsDecorator(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzer = Analyzer
TsDecorator.prototype.transform = function (node, parent) {
var analyzer = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.Decorator, node);
let clazz;
var clazz;
if (parent.type == "Class")

@@ -21,3 +23,3 @@ clazz = parent;

else
clazz = parent.children.filter(x => x.name == analyzer.getClassName())[0];
clazz = parent.children.filter(function (x) { return x.name == analyzer.getClassName(); })[0];
if (analyzer.isMethodDecorator()) {

@@ -32,9 +34,9 @@ this.transformMethod(node, clazz, analyzer);

}
}
transformProperty(node, clazz, analyzer) {
let methodName = analyzer.getMethodName();
};
TsDecorator.prototype.transformProperty = function (node, clazz, analyzer) {
var methodName = analyzer.getMethodName();
if (clazz) {
//property is special, because it only appears only on run time,
//so here we add it manually
let property = {
var property = {
type: "Property",

@@ -55,7 +57,7 @@ name: analyzer.getMethodName(),

}
}
transformMethod(node, clazz, analyzer) {
let methodName = analyzer.getMethodName();
};
TsDecorator.prototype.transformMethod = function (node, clazz, analyzer) {
var methodName = analyzer.getMethodName();
if (clazz && clazz.methods) {
let method = clazz.methods.filter(x => x.name == methodName)[0];
var method = clazz.methods.filter(function (x) { return x.name == methodName; })[0];
this.traverse(analyzer.getChildren(), method, [

@@ -65,4 +67,4 @@ new ts_child_decorator_1.TsChildDecoratorTransformer(this.parserType)

}
}
transformClass(node, clazz, analyzer) {
};
TsDecorator.prototype.transformClass = function (node, clazz, analyzer) {
if (clazz) {

@@ -73,7 +75,8 @@ this.traverse(analyzer.getChildren(), clazz, [

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ExpressionStatement)
], TsDecorator.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ExpressionStatement)
], TsDecorator.prototype, "transform", null);
return TsDecorator;
}(Core.TransformerBase));
exports.TsDecorator = TsDecorator;

57

lib/transformers/ts-module.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const Core = require("../core");
const ts_class_1 = require("./ts-class");
const ts_decorator_1 = require("./ts-decorator");
const ts_class_export_1 = require("./ts-class-export");
const es6_class_1 = require("./es6-class");
class TsModuleTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var Core = require("../core");
var ts_class_1 = require("./ts-class");
var ts_decorator_1 = require("./ts-decorator");
var ts_class_export_1 = require("./ts-class-export");
var es6_class_1 = require("./es6-class");
var TsModuleTransformer = /** @class */ (function (_super) {
tslib_1.__extends(TsModuleTransformer, _super);
function TsModuleTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyzer = Analyzer
TsModuleTransformer.prototype.transform = function (node, parent) {
var analyzer = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.TSModule, node);
if (analyzer.isCandidate() && (parent.type == "Module" || parent.type == "File")) {
let module = {
var module_1 = {
type: "Module",

@@ -26,4 +28,4 @@ analysis: Core.AnalysisType.Candidate,

};
parent.children.push(module);
this.traverse(analyzer.getBody(), module, [
parent.children.push(module_1);
this.traverse(analyzer.getBody(), module_1, [
new es6_class_1.Es6ClassTransformer(this.parserType),

@@ -35,9 +37,9 @@ new ts_class_1.TsClassTransformer(this.parserType),

]);
this.analyse(module, parent, analyzer);
this.analyse(module_1, parent, analyzer);
}
}
analyse(module, parent, analyzer) {
let connected = module.children.length > 0
&& module.children.some(x => Core.flag(x.analysis, Core.AnalysisType.Valid));
let exported = analyzer.isExported(parent.type == "File" ? "exports" : parent.name);
};
TsModuleTransformer.prototype.analyse = function (module, parent, analyzer) {
var connected = module.children.length > 0
&& module.children.some(function (x) { return Core.flag(x.analysis, Core.AnalysisType.Valid); });
var exported = analyzer.isExported(parent.type == "File" ? "exports" : parent.name);
if (exported)

@@ -49,7 +51,8 @@ module.analysis |= Core.AnalysisType.Exported;

module.analysis |= Core.AnalysisType.Valid;
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ExpressionStatement)
], TsModuleTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.ExpressionStatement)
], TsModuleTransformer.prototype, "transform", null);
return TsModuleTransformer;
}(Core.TransformerBase));
exports.TsModuleTransformer = TsModuleTransformer;

106

lib/transformers/value.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const Analyzer = require("../analyzers");
const Core = require("../core");
class BooleanValueTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var tslib_1 = require("tslib");
var Analyzer = require("../analyzers");
var Core = require("../core");
var BooleanValueTransformer = /** @class */ (function (_super) {
tslib_1.__extends(BooleanValueTransformer, _super);
function BooleanValueTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyser = Analyzer
BooleanValueTransformer.prototype.transform = function (node, parent) {
var analyser = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node);

@@ -22,15 +24,18 @@ if (analyser.isPrimitive()) {

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.BooleanLiteral)
], BooleanValueTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.BooleanLiteral)
], BooleanValueTransformer.prototype, "transform", null);
return BooleanValueTransformer;
}(Core.TransformerBase));
exports.BooleanValueTransformer = BooleanValueTransformer;
class StringValueTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var StringValueTransformer = /** @class */ (function (_super) {
tslib_1.__extends(StringValueTransformer, _super);
function StringValueTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyser = Analyzer
StringValueTransformer.prototype.transform = function (node, parent) {
var analyser = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node);

@@ -45,15 +50,18 @@ if (analyser.isPrimitive()) {

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.StringLiteral)
], StringValueTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.StringLiteral)
], StringValueTransformer.prototype, "transform", null);
return StringValueTransformer;
}(Core.TransformerBase));
exports.StringValueTransformer = StringValueTransformer;
class NumberValueTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var NumberValueTransformer = /** @class */ (function (_super) {
tslib_1.__extends(NumberValueTransformer, _super);
function NumberValueTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyser = Analyzer
NumberValueTransformer.prototype.transform = function (node, parent) {
var analyser = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node);

@@ -68,15 +76,18 @@ if (analyser.isPrimitive()) {

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.NumericLiteral)
], NumberValueTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.NumericLiteral)
], NumberValueTransformer.prototype, "transform", null);
return NumberValueTransformer;
}(Core.TransformerBase));
exports.NumberValueTransformer = NumberValueTransformer;
class NullValueTransformer extends Core.TransformerBase {
constructor(parserType) {
super();
this.parserType = parserType;
var NullValueTransformer = /** @class */ (function (_super) {
tslib_1.__extends(NullValueTransformer, _super);
function NullValueTransformer(parserType) {
var _this = _super.call(this) || this;
_this.parserType = parserType;
return _this;
}
transform(node, parent) {
let analyser = Analyzer
NullValueTransformer.prototype.transform = function (node, parent) {
var analyser = Analyzer
.get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node);

@@ -91,7 +102,8 @@ if (analyser.isNull()) {

}
}
}
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.NullLiteral)
], NullValueTransformer.prototype, "transform", null);
};
tslib_1.__decorate([
Core.Call.when(Core.SyntaxKind.NullLiteral)
], NullValueTransformer.prototype, "transform", null);
return NullValueTransformer;
}(Core.TransformerBase));
exports.NullValueTransformer = NullValueTransformer;

2

package.json
{
"name": "kecubung",
"version": "0.5.0-alpha.695401af",
"version": "0.5.0-alpha.70d3c872",
"description": "Javascript transformer to Type Metadata",

@@ -5,0 +5,0 @@ "main": "lib/index.js",

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc