Initial Save

node_modules/deprecated-decorator/README.md

@@ -0,0 +1,89 @@
+[![NPM Package](https://badge.fury.io/js/deprecated-decorator.svg)](https://www.npmjs.com/package/deprecated-decorator)
+[![Build Status](https://travis-ci.org/vilic/deprecated-decorator.svg)](https://travis-ci.org/vilic/deprecated-decorator) 
+
+# Deprecated Decorator
+
+A simple decorator for deprecated properties, methods and classes. It can also wrap normal functions via the old-fashioned way.
+
+Transpilers supported:
+
+- **TypeScript** with `experimentalDecorators` option enabled.
+- **Babel** with [transform-decorators-legacy](https://github.com/loganfsmyth/babel-plugin-transform-decorators-legacy) for version 6.x.
+
+## Install
+
+```sh
+npm install deprecated-decorator --save
+```
+
+## API References
+
+```ts
+export declare type DeprecatedDecorator = ClassDecorator & PropertyDecorator;
+
+export interface DeprecatedOptions {
+    alternative?: string;
+    version?: string;
+    url?: string;
+}
+
+export declare function deprecated(options?: DeprecatedOptions): DeprecatedDecorator;
+export declare function deprecated(alternative?: string, version?: string, url?: string): DeprecatedDecorator;
+
+export declare function deprecated<T extends Function>(fn: T): T;
+export declare function deprecated<T extends Function>(options: DeprecatedOptions, fn: T): T;
+export declare function deprecated<T extends Function>(alternative: string, fn: T): T;
+export declare function deprecated<T extends Function>(alternative: string, version: string, fn: T): T;
+export declare function deprecated<T extends Function>(alternative: string, version: string, url: string, fn: T): T;
+
+export default deprecated;
+```
+
+## Usage
+
+Decorating a class will enable warning on constructor and static methods (including static getters and setters):
+
+```ts
+import deprecated from 'deprecated-decorator';
+
+// alternative, since version, url
+@deprecated('Bar', '0.1.0', 'http://vane.life/')
+class Foo {
+    static method() { }
+}
+```
+
+Or you can decorate methods respectively:
+
+```ts
+import deprecated from 'deprecated-decorator';
+
+class Foo {
+    @deprecated('otherMethod')
+    method() { }
+    
+    @deprecated({
+        alternative: 'otherProperty',
+        version: '0.1.2',
+        url: 'http://vane.life/'
+    })
+    get property() { }
+}
+```
+
+For functions:
+
+```ts
+import deprecated from 'deprecated-decorator';
+
+let foo = deprecated({
+    alternative: 'bar',
+    version: '0.1.0'
+}, function foo() {
+    // ...
+});
+```
+
+## License
+
+MIT License.

node_modules/deprecated-decorator/bld/index.d.ts

@@ -0,0 +1,14 @@
+export declare type DeprecatedDecorator = ClassDecorator & PropertyDecorator;
+export interface DeprecatedOptions {
+    alternative?: string;
+    version?: string;
+    url?: string;
+}
+export declare function deprecated(options?: DeprecatedOptions): DeprecatedDecorator;
+export declare function deprecated(alternative?: string, version?: string, url?: string): DeprecatedDecorator;
+export declare function deprecated<T extends Function>(fn: T): T;
+export declare function deprecated<T extends Function>(options: DeprecatedOptions, fn: T): T;
+export declare function deprecated<T extends Function>(alternative: string, fn: T): T;
+export declare function deprecated<T extends Function>(alternative: string, version: string, fn: T): T;
+export declare function deprecated<T extends Function>(alternative: string, version: string, url: string, fn: T): T;
+export default deprecated;

node_modules/deprecated-decorator/bld/index.js

@@ -0,0 +1,170 @@
+/*
+    Deprecated Decorator v0.1
+    https://github.com/vilic/deprecated-decorator
+*/
+"use strict";
+/** @internal */
+exports.options = {
+    getWarner: undefined
+};
+function createWarner(type, name, alternative, version, url) {
+    var warnedPositions = {};
+    return function () {
+        var stack = (new Error()).stack || '';
+        var at = (stack.match(/(?:\s+at\s.+){2}\s+at\s(.+)/) || [undefined, ''])[1];
+        if (/\)$/.test(at)) {
+            at = at.match(/[^(]+(?=\)$)/)[0];
+        }
+        else {
+            at = at.trim();
+        }
+        if (at in warnedPositions) {
+            return;
+        }
+        warnedPositions[at] = true;
+        var message;
+        switch (type) {
+            case 'class':
+                message = 'Class';
+                break;
+            case 'property':
+                message = 'Property';
+                break;
+            case 'method':
+                message = 'Method';
+                break;
+            case 'function':
+                message = 'Function';
+                break;
+        }
+        message += " `" + name + "` has been deprecated";
+        if (version) {
+            message += " since version " + version;
+        }
+        if (alternative) {
+            message += ", use `" + alternative + "` instead";
+        }
+        message += '.';
+        if (at) {
+            message += "\n    at " + at;
+        }
+        if (url) {
+            message += "\nCheck out " + url + " for more information.";
+        }
+        console.warn(message);
+    };
+}
+function decorateProperty(type, name, descriptor, alternative, version, url) {
+    var warner = (exports.options.getWarner || createWarner)(type, name, alternative, version, url);
+    descriptor = descriptor || {
+        writable: true,
+        enumerable: false,
+        configurable: true
+    };
+    var deprecatedDescriptor = {
+        enumerable: descriptor.enumerable,
+        configurable: descriptor.configurable
+    };
+    if (descriptor.get || descriptor.set) {
+        if (descriptor.get) {
+            deprecatedDescriptor.get = function () {
+                warner();
+                return descriptor.get.call(this);
+            };
+        }
+        if (descriptor.set) {
+            deprecatedDescriptor.set = function (value) {
+                warner();
+                return descriptor.set.call(this, value);
+            };
+        }
+    }
+    else {
+        var propertyValue_1 = descriptor.value;
+        deprecatedDescriptor.get = function () {
+            warner();
+            return propertyValue_1;
+        };
+        if (descriptor.writable) {
+            deprecatedDescriptor.set = function (value) {
+                warner();
+                propertyValue_1 = value;
+            };
+        }
+    }
+    return deprecatedDescriptor;
+}
+function decorateFunction(type, target, alternative, version, url) {
+    var name = target.name;
+    var warner = (exports.options.getWarner || createWarner)(type, name, alternative, version, url);
+    var fn = function () {
+        warner();
+        return target.apply(this, arguments);
+    };
+    for (var _i = 0, _a = Object.getOwnPropertyNames(target); _i < _a.length; _i++) {
+        var propertyName = _a[_i];
+        var descriptor = Object.getOwnPropertyDescriptor(target, propertyName);
+        if (descriptor.writable) {
+            fn[propertyName] = target[propertyName];
+        }
+        else if (descriptor.configurable) {
+            Object.defineProperty(fn, propertyName, descriptor);
+        }
+    }
+    return fn;
+}
+function deprecated() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i - 0] = arguments[_i];
+    }
+    var fn = args[args.length - 1];
+    if (typeof fn === 'function') {
+        fn = args.pop();
+    }
+    else {
+        fn = undefined;
+    }
+    var options = args[0];
+    var alternative;
+    var version;
+    var url;
+    if (typeof options === 'string') {
+        alternative = options;
+        version = args[1];
+        url = args[2];
+    }
+    else if (options) {
+        (alternative = options.alternative, version = options.version, url = options.url, options);
+    }
+    if (fn) {
+        return decorateFunction('function', fn, alternative, version, url);
+    }
+    return function (target, name, descriptor) {
+        if (typeof name === 'string') {
+            var type = descriptor && typeof descriptor.value === 'function' ?
+                'method' : 'property';
+            return decorateProperty(type, name, descriptor, alternative, version, url);
+        }
+        else if (typeof target === 'function') {
+            var constructor = decorateFunction('class', target, alternative, version, url);
+            var className = target.name;
+            for (var _i = 0, _a = Object.getOwnPropertyNames(constructor); _i < _a.length; _i++) {
+                var propertyName = _a[_i];
+                var descriptor_1 = Object.getOwnPropertyDescriptor(constructor, propertyName);
+                descriptor_1 = decorateProperty('class', className, descriptor_1, alternative, version, url);
+                if (descriptor_1.writable) {
+                    constructor[propertyName] = target[propertyName];
+                }
+                else if (descriptor_1.configurable) {
+                    Object.defineProperty(constructor, propertyName, descriptor_1);
+                }
+            }
+            return constructor;
+        }
+    };
+}
+exports.deprecated = deprecated;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = deprecated;
+//# sourceMappingURL=index.js.map

node_modules/deprecated-decorator/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "deprecated-decorator",
+  "version": "0.1.6",
+  "description": "A simple decorator for deprecated methods and properties.",
+  "main": "bld/index.js",
+  "typings": "bld/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node node_modules/mocha/bin/_mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vilic/deprecated-decorator.git"
+  },
+  "keywords": ["deprecated", "decorator", "typescript", "babel", "es7"],
+  "author": "vilicvane",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vilic/deprecated-decorator/issues"
+  },
+  "homepage": "https://github.com/vilic/deprecated-decorator#readme",
+  "devDependencies": {
+    "chai": "latest",
+    "mocha": "latest",
+    "sinon": "latest",
+    "source-map-support": "latest",
+    "typescript": "latest"
+  }
+}