@codebakery/origami
Version:
Angular + Polymer
153 lines • 17.3 kB
JavaScript
import { __awaiter, __decorate, __generator, __param } from "tslib";
import { Directive, ElementRef, Inject, Optional, NgZone } from '@angular/core';
import { whenSet, wrapAndDefineDescriptor } from '@codebakery/origami/util';
import { camelToDashCase } from '@polymer/polymer/lib/utils/case-map';
import { POLYMER_HOST } from './polymerHost';
/**
* This directive is attached to each `<template>` element. If a Polymer host
* component is provided, this directive will enable Polymer's event and
* two-way binding syntax styles.
*/
var TemplateDirective = /** @class */ (function () {
function TemplateDirective(elementRef, polymerHost, zone) {
var _this = this;
this.elementRef = elementRef;
this.polymerHost = polymerHost;
this.zone = zone;
this.ready = (function () { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.polymerHost) return [3 /*break*/, 2];
this.enableEventBindings(elementRef.nativeElement);
return [4 /*yield*/, this.enablePropertyBindings(elementRef.nativeElement)];
case 1:
_a.sent();
_a.label = 2;
case 2: return [2 /*return*/];
}
});
}); })();
}
/**
* Enables the use of Polymer event bindings. An event binding is declared
* with the syntax `on-event-name="handler"`, where `event-name` is the
* name of the event to listen to and `handler` is the name of the host's
* method to call when the event is dispatched.
*
* @param template the Polymer template to enable event binding syntax for
*/
TemplateDirective.prototype.enableEventBindings = function (template) {
// When templatize looks for a PropertyEffects host, it will use the
// template's __dataHost property. This is the _methodHost for a template
// instance and is used to add event listener bindings.
template.__dataHost = this.polymerHost;
};
/**
* Enables the use of Polymer property bindings. A property binding is
* declared either as a one-way binding `value="[[propName]]"` or a two-way
* binding `value="{{propName}}"`.
*
* @param template the Polymer template to enable data binding syntax for
*/
TemplateDirective.prototype.enablePropertyBindings = function (template) {
return __awaiter(this, void 0, void 0, function () {
var hostProps, _loop_1, this_1, prop;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.getTemplateInfo(template)];
case 1:
hostProps = (_a.sent()).hostProps;
if (hostProps) {
_loop_1 = function (prop) {
// Angular -> Polymer (one-way bindings)
var initialValue = this_1.polymerHost[prop];
wrapAndDefineDescriptor(this_1.polymerHost, prop, {
afterSet: function (changed, value) {
if (changed) {
template["_host_" + prop] = value;
}
}
});
this_1.polymerHost[prop] = initialValue;
// Polymer -> Angular (two-way bindings)
var eventName = "_host_" + camelToDashCase(prop) + "-changed";
template.addEventListener(eventName, function (event) {
if (!_this.isSplicesChange(event) &&
!_this.isPathChange(event)) {
_this.zone.run(function () {
_this.polymerHost[prop] = event.detail.value;
});
}
});
};
this_1 = this;
for (prop in hostProps) {
_loop_1(prop);
}
}
return [2 /*return*/];
}
});
});
};
/**
* Retrieves the template info metadata for a Polymer template.
*
* @param template the Polymer template to retrieve template info for
* @returns a Promise that resolves with the template's info
*/
TemplateDirective.prototype.getTemplateInfo = function (template) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!template._templateInfo) return [3 /*break*/, 1];
return [2 /*return*/, template._templateInfo];
case 1: return [4 /*yield*/, whenSet(template, '_templateInfo')];
case 2: return [2 /*return*/, _a.sent()];
}
});
});
};
/**
* Indicates whether or not an event is a "splices" Polymer change event,
* which has a detail value object that dictates what elements were changed if
* the array reference remains the same.
*
* @param event the event to check
* @returns true if the event is a splices change event
*/
TemplateDirective.prototype.isSplicesChange = function (event) {
var value = event.detail.value;
return value && Array.isArray(value.indexSplices);
};
/**
* Indicates whether or not an event is a path Polymer change event, which
* has a detail path property indicating the path of the value changed, and a
* value of the path's value. This is used when an array or object reference
* remains the same.
*
* @param event the event to check
* @returns true if the event is a path change event
*/
TemplateDirective.prototype.isPathChange = function (event) {
return typeof event.detail.path === 'string';
};
TemplateDirective.ctorParameters = function () { return [
{ type: ElementRef },
{ type: undefined, decorators: [{ type: Inject, args: [POLYMER_HOST,] }, { type: Optional }] },
{ type: NgZone }
]; };
TemplateDirective = __decorate([
Directive({
selector: 'template'
}),
__param(1, Inject(POLYMER_HOST)),
__param(1, Optional())
], TemplateDirective);
return TemplateDirective;
}());
export { TemplateDirective };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.directive.js","sourceRoot":"ng://@codebakery/origami/templates/","sources":["src/template.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Inject, Optional, NgZone } from '@angular/core';\nimport { whenSet, wrapAndDefineDescriptor } from '@codebakery/origami/util';\nimport { camelToDashCase } from '@polymer/polymer/lib/utils/case-map';\nimport { TemplateInfo } from '@polymer/polymer/interfaces';\nimport { POLYMER_HOST } from './polymerHost';\n\n/**\n * An HTMLTemplateElement that is processed by Polymer's templatizer.\n */\nexport interface PolymerTemplate extends HTMLTemplateElement {\n  /**\n   * Added by the `PropertyEffects` mixin to instruct templatize of the host\n   * for the template. Effects that are not part of the template instance will\n   * propagate to this host.\n   */\n  __dataHost?: any;\n  /**\n   * Template metadata generated from `TemplateStamp`.\n   */\n  _templateInfo?: TemplateInfo;\n  /**\n   * Host properties are defined as `_host_propName` by templatizer.\n   */\n  [hostProp: string]: any;\n}\n\n/**\n * This directive is attached to each `<template>` element. If a Polymer host\n * component is provided, this directive will enable Polymer's event and\n * two-way binding syntax styles.\n */\n@Directive({\n  selector: 'template'\n})\nexport class TemplateDirective {\n  ready: Promise<void>;\n\n  constructor(\n    public elementRef: ElementRef,\n    @Inject(POLYMER_HOST)\n    @Optional()\n    public polymerHost: any,\n    private zone: NgZone\n  ) {\n    this.ready = (async () => {\n      if (this.polymerHost) {\n        this.enableEventBindings(elementRef.nativeElement);\n        await this.enablePropertyBindings(elementRef.nativeElement);\n      }\n    })();\n  }\n\n  /**\n   * Enables the use of Polymer event bindings. An event binding is declared\n   * with the syntax `on-event-name=\"handler\"`, where `event-name` is the\n   * name of the event to listen to and `handler` is the name of the host's\n   * method to call when the event is dispatched.\n   *\n   * @param template the Polymer template to enable event binding syntax for\n   */\n  enableEventBindings(template: PolymerTemplate) {\n    // When templatize looks for a PropertyEffects host, it will use the\n    // template's __dataHost property. This is the _methodHost for a template\n    // instance and is used to add event listener bindings.\n    template.__dataHost = this.polymerHost;\n  }\n\n  /**\n   * Enables the use of Polymer property bindings. A property binding is\n   * declared either as a one-way binding `value=\"[[propName]]\"` or a two-way\n   * binding `value=\"{{propName}}\"`.\n   *\n   * @param template the Polymer template to enable data binding syntax for\n   */\n  async enablePropertyBindings(template: PolymerTemplate) {\n    const { hostProps } = await this.getTemplateInfo(template);\n    if (hostProps) {\n      for (let prop in hostProps) {\n        // Angular -> Polymer (one-way bindings)\n        const initialValue = this.polymerHost[prop];\n        wrapAndDefineDescriptor(this.polymerHost, prop, {\n          afterSet(changed: boolean, value: any) {\n            if (changed) {\n              template[`_host_${prop}`] = value;\n            }\n          }\n        });\n\n        this.polymerHost[prop] = initialValue;\n\n        // Polymer -> Angular (two-way bindings)\n        const eventName = `_host_${camelToDashCase(prop)}-changed`;\n        template.addEventListener(eventName, event => {\n          if (\n            !this.isSplicesChange(<CustomEvent>event) &&\n            !this.isPathChange(<CustomEvent>event)\n          ) {\n            this.zone.run(() => {\n              this.polymerHost[prop] = (<CustomEvent>event).detail.value;\n            });\n          }\n        });\n      }\n    }\n  }\n\n  /**\n   * Retrieves the template info metadata for a Polymer template.\n   *\n   * @param template the Polymer template to retrieve template info for\n   * @returns a Promise that resolves with the template's info\n   */\n  async getTemplateInfo(template: PolymerTemplate): Promise<TemplateInfo> {\n    if (template._templateInfo) {\n      return template._templateInfo;\n    } else {\n      return await whenSet(template, '_templateInfo');\n    }\n  }\n\n  /**\n   * Indicates whether or not an event is a \"splices\" Polymer change event,\n   * which has a detail value object that dictates what elements were changed if\n   * the array reference remains the same.\n   *\n   * @param event the event to check\n   * @returns true if the event is a splices change event\n   */\n  private isSplicesChange(event: CustomEvent): boolean {\n    const value = event.detail.value;\n    return value && Array.isArray(value.indexSplices);\n  }\n\n  /**\n   * Indicates whether or not an event is a path Polymer change event, which\n   * has a detail path property indicating the path of the value changed, and a\n   * value of the path's value. This is used when an array or object reference\n   * remains the same.\n   *\n   * @param event the event to check\n   * @returns true if the event is a path change event\n   */\n  private isPathChange(event: CustomEvent): boolean {\n    return typeof event.detail.path === 'string';\n  }\n}\n"]}