diff --git a/.gitignore b/.gitignore index bfa3b1b..33db605 100644 --- a/.gitignore +++ b/.gitignore @@ -2,9 +2,5 @@ *.log npm-debug.log* node_modules -.npm -!gulpfile.js -*.map -*.html bower_components -dist +.npm diff --git a/.npmignore b/.npmignore new file mode 100644 index 0000000..33db605 --- /dev/null +++ b/.npmignore @@ -0,0 +1,6 @@ +.idea +*.log +npm-debug.log* +node_modules +bower_components +.npm diff --git a/bower.json b/bower.json new file mode 100644 index 0000000..8cd8d1d --- /dev/null +++ b/bower.json @@ -0,0 +1,34 @@ +{ + "name": "easy-polymer", + "version": "0.5.0", + "description": "EaSy Polymer is a set of ES7/TS decorators for Polymer to save on boilerplate", + "main": "dist/html/esp.html", + "authors": [ + "Draccoz" + ], + "license": "ISC", + "keywords": [ + "polymer", + "decorator", + "typescript", + "es7", + "es2016" + ], + "repository": { + "type": "git", + "url": "https://github.com/Draccoz/easy-polymer" + }, + "homepage": "https://github.com/Draccoz/easy-polymer", + "moduleType": [ + "es6", + "globals", + "node" + ], + "ignore": [ + "**/.*", + "node_modules", + "bower_components", + "test", + "tests" + ] +} diff --git a/dist/cjs/esp.js b/dist/cjs/esp.js new file mode 100644 index 0000000..c8a9fd5 --- /dev/null +++ b/dist/cjs/esp.js @@ -0,0 +1,156 @@ +var PRIMITIVES = [String, Number, Boolean, Date, Object, Array]; +function getPropertyDescriptor(proto, key) { + var config = proto.config = proto.config || {}; + var properties = config.properties = config.properties || {}; + return properties[key] = properties[key] || {}; +} +function defineComponent(target) { + var opts = this || {}; + var prototype = target.prototype; + var config = prototype.config; + var name = opts.name || target.name.replace(/[A-Z]/g, function (c, i) { return ("" + (i === 0 ? "" : "-") + c.toLowerCase()); }); + if (parseFloat(Polymer["version"]) < 2) { + prototype.is = name; + Object.keys(config).forEach(function (key) { return prototype[key] = config[key]; }); + Polymer(prototype); + } + else { + Object.defineProperties(target, { + is: { get: function () { return name; } }, + config: { get: function () { return config; } } + }); + customElements.define(target.is, target); + } +} +function define(arg) { + if (arg instanceof Function) { + defineComponent(arg); + } + else if (typeof arg === "string") { + return defineComponent.bind({ name: arg }); + } +} +exports.define = define; +function template(tpl) { + return function (target) { + var module = document.createElement("dom-module"); + var templateElement = document.createElement("template"); + module.appendChild(templateElement); + templateElement.innerHTML = tpl; + module.id = target.name.replace(/[A-Z]/g, function (c, i) { return ("" + (i === 0 ? "" : "-") + c.toLowerCase()); }); + module["register"](); + }; +} +exports.template = template; +function prop(proto, key) { + getPropertyDescriptor(proto, key).type = Reflect["getMetadata"]("design:type", proto, key); +} +exports.prop = prop; +function string(proto, key) { + getPropertyDescriptor(proto, key).type = String; +} +exports.string = string; +function number(proto, key) { + getPropertyDescriptor(proto, key).type = Number; +} +exports.number = number; +function boolean(proto, key) { + getPropertyDescriptor(proto, key).type = Boolean; +} +exports.boolean = boolean; +function date(proto, key) { + getPropertyDescriptor(proto, key).type = Date; +} +exports.date = date; +function object(proto, key) { + getPropertyDescriptor(proto, key).type = Object; +} +exports.object = object; +function array(proto, key) { + getPropertyDescriptor(proto, key).type = Array; +} +exports.array = array; +function attr(proto, key) { + getPropertyDescriptor(proto, key).reflectToAttribute = true; +} +exports.attr = attr; +function set(value) { + return function (proto, key) { + getPropertyDescriptor(proto, key).value = value; + }; +} +exports.set = set; +function readOnly(value) { + return function (proto, key) { + var descriptor = getPropertyDescriptor(proto, key); + descriptor.readOnly = true; + descriptor.value = value; + }; +} +exports.readOnly = readOnly; +function notify(proto, key) { + getPropertyDescriptor(proto, key).notify = true; +} +exports.notify = notify; +function computedProperty(proto, key) { + var options = this || {}; + var handler = proto[key]; + if (!handler) { + throw new TypeError("@computed can only be applied to a method (`" + key + "` is not a method)"); + } + var props = options.props || handler.toString().match(/.*?\(([^\)]+?)\)/)[1]; + var type = options.type || Reflect["getMetadata"]("design:returntype", proto, key); + var descriptor = getPropertyDescriptor(proto, key); + descriptor.type = type; + descriptor.computed = "__" + key + "(" + props + ")"; + proto[("__" + key)] = handler; +} +function observeProperty(proto, key) { + var options = this || {}; + var handler = proto[key]; + if (!handler) { + throw new TypeError("@observe can only be applied to a method (`" + key + "` is not a method)"); + } + var args = options.args || handler.toString().match(/.*?\(([^\)]+?)\)/)[1]; + var dependencies = args.split(/, ?/g); + if (dependencies.length === 0) { + throw new SyntaxError("Observable method should contain observed properties," + + " or @observe decorator should be provided a list of properties"); + } + if (dependencies.length === 1 && dependencies[0].indexOf(".") === -1) { + var descriptor = getPropertyDescriptor(proto, dependencies[0]); + descriptor.observer = key; + } + else { + var config = proto.config = proto.config || {}; + var observers = config.observers = config.observers || []; + observers.push(key + "(" + args + ")"); + } +} +function computed() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + var arg0 = args[0]; + if (PRIMITIVES.indexOf(arg0) !== -1) { + return computedProperty.bind({ type: arg0, props: typeof arg0 === "string" ? args[1] : undefined }); + } + else if (typeof arg0 === "string") { + return computedProperty.bind({ props: arg0 }); + } + computedProperty(arg0, args[1]); +} +exports.computed = computed; +function observe() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + var arg0 = args[0]; + if (typeof arg0 === "string") { + return observeProperty.bind({ args: arg0 }); + } + observeProperty(arg0, args[1]); +} +exports.observe = observe; diff --git a/dist/cjs/esp.min.js b/dist/cjs/esp.min.js new file mode 100644 index 0000000..e1e5f8b --- /dev/null +++ b/dist/cjs/esp.min.js @@ -0,0 +1 @@ +function getPropertyDescriptor(e,t){var r=e.config=e.config||{},o=r.properties=r.properties||{};return o[t]=o[t]||{}}function defineComponent(e){var t=this||{},r=e.prototype,o=r.config,n=t.name||e.name.replace(/[A-Z]/g,function(e,t){return""+(0===t?"":"-")+e.toLowerCase()});parseFloat(Polymer.version)<2?(r.is=n,Object.keys(o).forEach(function(e){return r[e]=o[e]}),Polymer(r)):(Object.defineProperties(e,{is:{get:function(){return n}},config:{get:function(){return o}}}),customElements.define(e.is,e))}function define(e){if(e instanceof Function)defineComponent(e);else if("string"==typeof e)return defineComponent.bind({name:e})}function template(e){return function(t){var r=document.createElement("dom-module"),o=document.createElement("template");r.appendChild(o),o.innerHTML=e,r.id=t.name.replace(/[A-Z]/g,function(e,t){return""+(0===t?"":"-")+e.toLowerCase()}),r.register()}}function prop(e,t){getPropertyDescriptor(e,t).type=Reflect.getMetadata("design:type",e,t)}function string(e,t){getPropertyDescriptor(e,t).type=String}function number(e,t){getPropertyDescriptor(e,t).type=Number}function boolean(e,t){getPropertyDescriptor(e,t).type=Boolean}function date(e,t){getPropertyDescriptor(e,t).type=Date}function object(e,t){getPropertyDescriptor(e,t).type=Object}function array(e,t){getPropertyDescriptor(e,t).type=Array}function attr(e,t){getPropertyDescriptor(e,t).reflectToAttribute=!0}function set(e){return function(t,r){getPropertyDescriptor(t,r).value=e}}function readOnly(e){return function(t,r){var o=getPropertyDescriptor(t,r);o.readOnly=!0,o.value=e}}function notify(e,t){getPropertyDescriptor(e,t).notify=!0}function computedProperty(e,t){var r=this||{},o=e[t];if(!o)throw new TypeError("@computed can only be applied to a method (`"+t+"` is not a method)");var n=r.props||o.toString().match(/.*?\(([^\)]+?)\)/)[1],p=r.type||Reflect.getMetadata("design:returntype",e,t),i=getPropertyDescriptor(e,t);i.type=p,i.computed="__"+t+"("+n+")",e["__"+t]=o}function observeProperty(e,t){var r=this||{},o=e[t];if(!o)throw new TypeError("@observe can only be applied to a method (`"+t+"` is not a method)");var n=r.args||o.toString().match(/.*?\(([^\)]+?)\)/)[1],p=n.split(/, ?/g);if(0===p.length)throw new SyntaxError("Observable method should contain observed properties, or @observe decorator should be provided a list of properties");if(1===p.length&&p[0].indexOf(".")===-1){var i=getPropertyDescriptor(e,p[0]);i.observer=t}else{var s=e.config=e.config||{},a=s.observers=s.observers||[];a.push(t+"("+n+")")}}function computed(){for(var e=[],t=0;t `${i === 0 ? "" : "-"}${c.toLowerCase()}`); + if (parseFloat(Polymer["version"]) < 2) { + prototype.is = name; + Object.keys(config).forEach(key => prototype[key] = config[key]); + Polymer(prototype); + } + else { + Object.defineProperties(target, { + is: { get: () => name }, + config: { get: () => config } + }); + customElements.define(target.is, target); + } +} +export function define(arg) { + if (arg instanceof Function) { + defineComponent(arg); + } + else if (typeof arg === "string") { + return defineComponent.bind({ name: arg }); + } +} +export function template(tpl) { + return target => { + let module = document.createElement("dom-module"); + let templateElement = document.createElement("template"); + module.appendChild(templateElement); + templateElement.innerHTML = tpl; + module.id = target.name.replace(/[A-Z]/g, (c, i) => `${i === 0 ? "" : "-"}${c.toLowerCase()}`); + module["register"](); + }; +} +export function prop(proto, key) { + getPropertyDescriptor(proto, key).type = Reflect["getMetadata"]("design:type", proto, key); +} +export function string(proto, key) { + getPropertyDescriptor(proto, key).type = String; +} +export function number(proto, key) { + getPropertyDescriptor(proto, key).type = Number; +} +export function boolean(proto, key) { + getPropertyDescriptor(proto, key).type = Boolean; +} +export function date(proto, key) { + getPropertyDescriptor(proto, key).type = Date; +} +export function object(proto, key) { + getPropertyDescriptor(proto, key).type = Object; +} +export function array(proto, key) { + getPropertyDescriptor(proto, key).type = Array; +} +export function attr(proto, key) { + getPropertyDescriptor(proto, key).reflectToAttribute = true; +} +export function set(value) { + return (proto, key) => { + getPropertyDescriptor(proto, key).value = value; + }; +} +export function readOnly(value) { + return (proto, key) => { + let descriptor = getPropertyDescriptor(proto, key); + descriptor.readOnly = true; + descriptor.value = value; + }; +} +export function notify(proto, key) { + getPropertyDescriptor(proto, key).notify = true; +} +function computedProperty(proto, key) { + let options = this || {}; + let handler = proto[key]; + if (!handler) { + throw new TypeError(`@computed can only be applied to a method (\`${key}\` is not a method)`); + } + let props = options.props || handler.toString().match(/.*?\(([^\)]+?)\)/)[1]; + let type = options.type || Reflect["getMetadata"]("design:returntype", proto, key); + let descriptor = getPropertyDescriptor(proto, key); + descriptor.type = type; + descriptor.computed = `__${key}(${props})`; + proto[`__${key}`] = handler; +} +function observeProperty(proto, key) { + let options = this || {}; + let handler = proto[key]; + if (!handler) { + throw new TypeError(`@observe can only be applied to a method (\`${key}\` is not a method)`); + } + let args = options.args || handler.toString().match(/.*?\(([^\)]+?)\)/)[1]; + let dependencies = args.split(/, ?/g); + if (dependencies.length === 0) { + throw new SyntaxError(`Observable method should contain observed properties,` + + ` or @observe decorator should be provided a list of properties`); + } + if (dependencies.length === 1 && dependencies[0].indexOf(".") === -1) { + let descriptor = getPropertyDescriptor(proto, dependencies[0]); + descriptor.observer = key; + } + else { + let config = proto.config = proto.config || {}; + let observers = config.observers = config.observers || []; + observers.push(`${key}(${args})`); + } +} +export function computed(...args) { + let arg0 = args[0]; + if (PRIMITIVES.indexOf(arg0) !== -1) { + return computedProperty.bind({ type: arg0, props: typeof arg0 === "string" ? args[1] : undefined }); + } + else if (typeof arg0 === "string") { + return computedProperty.bind({ props: arg0 }); + } + computedProperty(arg0, args[1]); +} +export function observe(...args) { + let arg0 = args[0]; + if (typeof arg0 === "string") { + return observeProperty.bind({ args: arg0 }); + } + observeProperty(arg0, args[1]); +} diff --git a/dist/html/esp.html b/dist/html/esp.html new file mode 100644 index 0000000..35c83bf --- /dev/null +++ b/dist/html/esp.html @@ -0,0 +1,160 @@ + \ No newline at end of file diff --git a/dist/html/esp.min.html b/dist/html/esp.min.html new file mode 100644 index 0000000..8dc9570 --- /dev/null +++ b/dist/html/esp.min.html @@ -0,0 +1,4 @@ + \ No newline at end of file diff --git a/package.json b/package.json index 2dcaf33..2fb0117 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "easy-polymer", - "version": "0.4.0", + "version": "0.5.0", "description": "EaSy Polymer is a set of ES7/TS decorators for Polymer to save on boilerplate", "main": "dist/node/esp.js", "jsnext:main": "dist/es6/esp.js", @@ -33,6 +33,7 @@ "gulp-transform": "^1.1.0", "gulp-tslint": "latest", "gulp-typescript": "^3.1.2", + "gulp-uglify": "^2.0.0", "gulpfile.ts": "0.0.2", "lodash": "^4.16.6", "ts-node": "^1.7.0",