@pebula/metap
Version:
meta-programming tools
227 lines • 18.3 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { array, } from '@pebula/metap/internal';
/**
* @record
*/
export function CompiledTransformation() { }
if (false) {
/**
* Excluded members that doesn't have a \@Prop decorator.
* All \@Exclude instructions on members with \@Prop instructions are add to the PoClassPropertyMap
* @type {?}
*/
CompiledTransformation.prototype.excluded;
/** @type {?} */
CompiledTransformation.prototype.instructions;
}
/**
* @param {?} value
* @param {?} prop
* @return {?}
*/
export function transformValueOut(value, prop) {
if (prop && prop.transform && prop.transform.outgoing) {
return prop.transform.outgoing(value);
}
return value;
}
/**
* @param {?} value
* @param {?} prop
* @return {?}
*/
export function transformValueIn(value, prop) {
if (prop && prop.transform && prop.transform.incoming) {
return prop.transform.incoming(value);
}
return value;
}
/**
* @param {?} e
* @return {?}
*/
function excludedPredicate(e) {
return e.name === this;
}
var InclusivePropertyContainer = /** @class */ (function () {
function InclusivePropertyContainer(target, compiled, predicate, renamer) {
this.target = target;
this.compiled = compiled;
this.predicate = predicate;
this.renamer = renamer;
}
/**
* @param {?} keys
* @param {?} cb
* @return {?}
*/
InclusivePropertyContainer.prototype.forEach = /**
* @param {?} keys
* @param {?} cb
* @return {?}
*/
function (keys, cb) {
/** @type {?} */
var len = keys.length;
/** @type {?} */
var instructions = this.compiled.instructions.slice();
/** @type {?} */
var excluded = this.compiled.excluded.slice();
for (var i = 0; i < len; i++) {
/** @type {?} */
var prop = array.findRemove(instructions, this.predicate, keys[i]) || {
cls: keys[i],
obj: keys[i],
exclude: array.findRemove(excluded, excludedPredicate, keys[i])
};
if (!prop.exclude) {
// we only transform names for ad-hoc properties. registered @Prop's are transformed
// when the prop is compiled.
if (!prop.prop && this.renamer) {
this.renamer(prop);
}
cb(prop);
}
}
};
/**
* A forEach loop on all instructions including excluded instructions and properties not in "keys" but in metadata.
* It is recommended to use "forEach" unless the mapper implementation has different transformation strategies.
* @param keys
* @param cb
*/
/**
* A forEach loop on all instructions including excluded instructions and properties not in "keys" but in metadata.
* It is recommended to use "forEach" unless the mapper implementation has different transformation strategies.
* @param {?} keys
* @param {?} cb
* @return {?}
*/
InclusivePropertyContainer.prototype.forEachRaw = /**
* A forEach loop on all instructions including excluded instructions and properties not in "keys" but in metadata.
* It is recommended to use "forEach" unless the mapper implementation has different transformation strategies.
* @param {?} keys
* @param {?} cb
* @return {?}
*/
function (keys, cb) {
/** @type {?} */
var len = keys.length;
/** @type {?} */
var instructions = this.compiled.instructions.slice();
/** @type {?} */
var excluded = this.compiled.excluded.slice();
for (var i = 0; i < len; i++) {
/** @type {?} */
var prop = array.findRemove(instructions, this.predicate, keys[i]) || {
cls: keys[i],
obj: keys[i],
exclude: array.findRemove(excluded, excludedPredicate, keys[i])
};
// we only transform names for ad-hoc properties. registered @Prop's are transformed
// when the prop is compiled.
if (!prop.prop && this.renamer) {
this.renamer(prop);
}
cb(prop);
}
len = instructions.length;
for (var i = 0; i < len; i++) {
/** @type {?} */
var prop = instructions[i];
// we only transform names for ad-hoc properties. registered @Prop's are transformed
// when the prop is compiled.
if (!prop.prop && this.renamer) {
this.renamer(prop);
}
cb(prop);
}
};
return InclusivePropertyContainer;
}());
export { InclusivePropertyContainer };
if (false) {
/** @type {?} */
InclusivePropertyContainer.prototype.target;
/**
* @type {?}
* @private
*/
InclusivePropertyContainer.prototype.compiled;
/**
* @type {?}
* @private
*/
InclusivePropertyContainer.prototype.predicate;
/**
* @type {?}
* @private
*/
InclusivePropertyContainer.prototype.renamer;
}
var ExclusivePropertyContainer = /** @class */ (function () {
function ExclusivePropertyContainer(target, compiled) {
this.target = target;
this.compiled = compiled;
}
/**
* @param {?} keys
* @param {?} cb
* @return {?}
*/
ExclusivePropertyContainer.prototype.forEach = /**
* @param {?} keys
* @param {?} cb
* @return {?}
*/
function (keys, cb) {
/** @type {?} */
var instructions = this.compiled.instructions;
// No need to apply transformNameStrategy, it is cached in the instructions.
for (var i = 0, len = instructions.length; i < len; i++) {
!instructions[i].exclude && cb(instructions[i]);
}
};
/**
* A forEach loop on all instructions including excluded instructions and properties not in "keys" but in metadata.
* It is recommended to use "forEach" unless the mapper implementation has different transformation strategies.
* @param keys
* @param cb
*/
/**
* A forEach loop on all instructions including excluded instructions and properties not in "keys" but in metadata.
* It is recommended to use "forEach" unless the mapper implementation has different transformation strategies.
* @param {?} keys
* @param {?} cb
* @return {?}
*/
ExclusivePropertyContainer.prototype.forEachRaw = /**
* A forEach loop on all instructions including excluded instructions and properties not in "keys" but in metadata.
* It is recommended to use "forEach" unless the mapper implementation has different transformation strategies.
* @param {?} keys
* @param {?} cb
* @return {?}
*/
function (keys, cb) {
/** @type {?} */
var instructions = this.compiled.instructions;
for (var i = 0, len = instructions.length; i < len; i++) {
cb(instructions[i]);
}
};
return ExclusivePropertyContainer;
}());
export { ExclusivePropertyContainer };
if (false) {
/** @type {?} */
ExclusivePropertyContainer.prototype.target;
/**
* @type {?}
* @private
*/
ExclusivePropertyContainer.prototype.compiled;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serialization-context.js","sourceRoot":"ng://@pebula/metap/","sources":["lib/serialization/mapping/serialization-context.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  PropMetadata,\n  ExcludeMetadata,\n  SerializerContext,\n  PoClassPropertyMap,\n  array,\n} from '@pebula/metap/internal';\n\n\nexport interface CompiledTransformation {\n  /**\n   * Excluded members that doesn't have a @Prop decorator.\n   * All @Exclude instructions on members with @Prop instructions are add to the PoClassPropertyMap\n   */\n  excluded: ExcludeMetadata[];\n  instructions: PoClassPropertyMap[];\n}\n\nexport function transformValueOut(value: any, prop: PropMetadata): any {\n  if (prop && prop.transform && prop.transform.outgoing) {\n    return prop.transform.outgoing(value);\n  }\n  return value;\n}\n\nexport function transformValueIn(value: any, prop: PropMetadata): any {\n  if (prop && prop.transform && prop.transform.incoming) {\n    return prop.transform.incoming(value);\n  }\n  return value;\n}\n\nfunction excludedPredicate(e: ExcludeMetadata) {\n  return e.name === this;\n}\n\nexport class InclusivePropertyContainer implements SerializerContext {\n  constructor(public target: any,\n              private compiled: CompiledTransformation,\n              private predicate: (p: PoClassPropertyMap) => boolean,\n              private renamer?: (po: PoClassPropertyMap) => string) {}\n\n  forEach(keys: string[], cb: (pMap: PoClassPropertyMap) => void): void {\n    let len = keys.length;\n\n    const instructions = this.compiled.instructions.slice();\n    const excluded = this.compiled.excluded.slice();\n\n    for (let i = 0; i < len; i++) {\n      let prop: PoClassPropertyMap = array.findRemove(\n        instructions,\n        this.predicate,\n        keys[i]\n      ) || {\n        cls: keys[i],\n        obj: keys[i],\n        exclude: array.findRemove(excluded, excludedPredicate, keys[i])\n      };\n\n      if (!prop.exclude) {\n        // we only transform names for ad-hoc properties. registered @Prop's are transformed\n        // when the prop is compiled.\n        if (!prop.prop && this.renamer) {\n          this.renamer(prop);\n        }\n        cb(prop);\n      }\n    }\n  }\n\n  /**\n   * A forEach loop on all instructions including excluded instructions and properties not in \"keys\" but in metadata.\n   * It is recommended to use \"forEach\" unless the mapper implementation has different transformation strategies.\n   * @param keys\n   * @param cb\n   */\n  forEachRaw(keys: string[], cb: (pMap: PoClassPropertyMap) => void): void {\n    let len = keys.length;\n\n    const instructions = this.compiled.instructions.slice();\n    const excluded = this.compiled.excluded.slice();\n\n    for (let i = 0; i < len; i++) {\n      let prop: PoClassPropertyMap = array.findRemove(\n        instructions,\n        this.predicate,\n        keys[i]\n      ) || {\n        cls: keys[i],\n        obj: keys[i],\n        exclude: array.findRemove(excluded, excludedPredicate, keys[i])\n      };\n\n      // we only transform names for ad-hoc properties. registered @Prop's are transformed\n      // when the prop is compiled.\n      if (!prop.prop && this.renamer) {\n        this.renamer(prop);\n      }\n      cb(prop);\n    }\n\n    len = instructions.length;\n    for (let i = 0; i < len; i++) {\n      let prop: PoClassPropertyMap = instructions[i];\n\n      // we only transform names for ad-hoc properties. registered @Prop's are transformed\n      // when the prop is compiled.\n      if (!prop.prop && this.renamer) {\n        this.renamer(prop);\n      }\n      cb(prop);\n    }\n  }\n}\n\nexport class ExclusivePropertyContainer implements SerializerContext {\n  constructor(public target: any, private compiled: CompiledTransformation) {}\n\n  forEach(keys: string[], cb: (pMap: PoClassPropertyMap) => void): void {\n    const instructions = this.compiled.instructions;\n    // No need to apply transformNameStrategy, it is cached in the instructions.\n    for (let i = 0, len = instructions.length; i < len; i++) {\n      !instructions[i].exclude && cb(instructions[i]);\n    }\n  }\n\n  /**\n   * A forEach loop on all instructions including excluded instructions and properties not in \"keys\" but in metadata.\n   * It is recommended to use \"forEach\" unless the mapper implementation has different transformation strategies.\n   * @param keys\n   * @param cb\n   */\n  forEachRaw(keys: string[], cb: (pMap: PoClassPropertyMap) => void): void {\n    const instructions = this.compiled.instructions;\n    for (let i = 0, len = instructions.length; i < len; i++) {\n      cb(instructions[i]);\n    }\n  }\n}\n"]}