ngx-modialog-11
Version:
Modal / Dialog for Angular
68 lines • 11.1 kB
JavaScript
import { FluentAssign } from '../framework/fluent-assign';
import { extend, arrayUnion } from '../framework/utils';
const ɵ0 = function supportsKey(keyCode) {
return this.keyboard.indexOf(keyCode) > -1;
};
export const DEFAULT_VALUES = {
inElement: false,
isBlocking: true,
keyboard: [27],
supportsKey: ɵ0
};
const DEFAULT_SETTERS = [
'inElement',
'isBlocking',
'keyboard'
];
export class OverlayContext {
normalize() {
if (this.isBlocking !== false) {
this.isBlocking = true;
}
if (this.keyboard === null) {
this.keyboard = [];
}
else if (typeof this.keyboard === 'number') {
this.keyboard = [this.keyboard];
}
else if (!Array.isArray(this.keyboard)) {
this.keyboard = DEFAULT_VALUES.keyboard;
}
}
}
/**
* A core context builder for a modal window instance, used to define the context upon
* a modal choose it's behaviour.
*/
export class OverlayContextBuilder extends FluentAssign {
constructor(defaultValues, initialSetters, baseType) {
super(extend(DEFAULT_VALUES, defaultValues || {}), arrayUnion(DEFAULT_SETTERS, initialSetters || []), baseType || OverlayContext // https://github.com/Microsoft/TypeScript/issues/7234
);
}
/**
* Returns an new OverlayConfig with a context property representing the data in this builder.
* @param base A base configuration that the result will extend
*/
toOverlayConfig(base) {
return extend(base || {}, {
context: this.toJSON()
});
}
}
/**
* A helper to create an `OverlayConfig` on the fly.
* Since `OverlayConfig` requires context it means a builder is needed, this process had some boilerplate.
* When a quick, on the fly overlay config is needed use this helper to avoid that boilerplate.
*
* A builder is used as an API to allow setting the context and providing some operations around the modal.
* When a developers knows the context before hand we can skip this step, this is what this factory is for.
*
* @param context The context for the modal
* @param baseContextType Optional. The type/class of the context. This is the class used to init a new instance of the context
* @param baseConfig A base configuration that the result will extend
*/
export function overlayConfigFactory(context, baseContextType, baseConfig) {
return new OverlayContextBuilder(context, undefined, baseContextType).toOverlayConfig(baseConfig);
}
export { ɵ0 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-context.js","sourceRoot":"","sources":["../../../../../projects/ngx-modialog-11/src/lib/models/overlay-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAsB,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;WAQzC,SAAS,WAAW,CAAC,OAAe;IAC/C,OAAuB,IAAI,CAAC,QAAS,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9D,CAAC;AANH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,SAAS,EAAE,KAAK;IAChB,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,CAAC,EAAE,CAAC;IACd,WAAW,IAEV;CACF,CAAC;AAEF,MAAM,eAAe,GAAG;IACtB,WAAW;IACX,YAAY;IACZ,UAAU;CACX,CAAC;AAEF,MAAM,OAAO,cAAc;IAuBzB,SAAS;QACP,IAAI,IAAI,CAAC,UAAU,KAAK,KAAK,EAAE;YAC7B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;SACxB;QAED,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE;YAC1B,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;SACpB;aAAM,IAAI,OAAO,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE;YAC5C,IAAI,CAAC,QAAQ,GAAG,CAAS,IAAI,CAAC,QAAQ,CAAC,CAAC;SACzC;aAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAgB,IAAI,CAAC,QAAQ,CAAC,EAAE;YACvD,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC;SACzC;IACH,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,qBAAgD,SAAQ,YAAe;IAwBlF,YAAY,aAAuB,EACvB,cAAyB,EACzB,QAAsB;QAChC,KAAK,CACH,MAAM,CAAM,cAAc,EAAE,aAAa,IAAI,EAAE,CAAC,EAChD,UAAU,CAAS,eAAe,EAAE,cAAc,IAAI,EAAE,CAAC,EACzD,QAAQ,IAAS,cAAc,CAAC,sDAAsD;SACvF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,IAAoB;QAClC,OAAO,MAAM,CAAC,IAAI,IAAI,EAAE,EAAE;YACxB,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE;SACvB,CAAC,CAAC;IACL,CAAC;CACF;AAMD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAAI,OAAU,EAAE,eAAqB,EAAE,UAA0B;IACnG,OAAO,IAAI,qBAAqB,CAA0B,OAAO,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;AAC7H,CAAC","sourcesContent":["import { FluentAssign, FluentAssignMethod } from '../framework/fluent-assign';\r\nimport { extend, arrayUnion } from '../framework/utils';\r\nimport { DialogRef } from './dialog-ref';\r\nimport { WideVCRef, OverlayConfig } from './tokens';\r\n\r\nexport const DEFAULT_VALUES = {\r\n  inElement: false,\r\n  isBlocking: true,\r\n  keyboard: [27],\r\n  supportsKey: function supportsKey(keyCode: number): boolean {\r\n    return (<Array<number>>this.keyboard).indexOf(keyCode) > -1;\r\n  }\r\n};\r\n\r\nconst DEFAULT_SETTERS = [\r\n  'inElement',\r\n  'isBlocking',\r\n  'keyboard'\r\n];\r\n\r\nexport class OverlayContext {\r\n  /**\r\n   * Describes if the modal is rendered within the container element.\r\n   * The container element is the ViewContainerRef supplied.\r\n   * Defaults to false.\r\n   */\r\n  inElement: boolean;\r\n\r\n  /**\r\n   * Describes if the modal is blocking modal.\r\n   * A Blocking modal is not closable by clicking outside of the modal window.\r\n   * Defaults to false.\r\n   */\r\n  isBlocking: boolean;\r\n\r\n  /**\r\n   * Keyboard value/s that close the modal.\r\n   * Accepts either a single numeric value or an array of numeric values.\r\n   * A modal closed by a keyboard stroke will result in a 'reject' notification from the promise.\r\n   * Defaults to 27, set `null` implicitly to disable.\r\n   */\r\n  keyboard: Array<number> | number;\r\n\r\n  normalize(): void {\r\n    if (this.isBlocking !== false) {\r\n      this.isBlocking = true;\r\n    }\r\n\r\n    if (this.keyboard === null) {\r\n      this.keyboard = [];\r\n    } else if (typeof this.keyboard === 'number') {\r\n      this.keyboard = [<number>this.keyboard];\r\n    } else if (!Array.isArray(<Array<number>>this.keyboard)) {\r\n      this.keyboard = DEFAULT_VALUES.keyboard;\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * A core context builder for a modal window instance, used to define the context upon\r\n * a modal choose it's behaviour.\r\n */\r\nexport class OverlayContextBuilder<T extends OverlayContext> extends FluentAssign<T> {\r\n  /**\r\n   * Describes if the modal is rendered within the container element.\r\n   * The container element is the ViewContainerRef supplied.\r\n   * Defaults to false.\r\n   */\r\n  inElement: FluentAssignMethod<boolean, this>;\r\n\r\n  /**\r\n   * Describes if the modal is blocking modal.\r\n   * A Blocking modal is not closable by clicking outside of the modal window.\r\n   * Defaults to false.\r\n   */\r\n  isBlocking: FluentAssignMethod<boolean, this>;\r\n\r\n  /**\r\n   * Keyboard value/s that close the modal.\r\n   * Accepts either a single numeric value or an array of numeric values.\r\n   * A modal closed by a keyboard stroke will result in a 'reject' notification from the promise.\r\n   * Defaults to 27, set `null` implicitly to disable.\r\n   */\r\n  keyboard: FluentAssignMethod<Array<number> | number, this>;\r\n\r\n\r\n  constructor(defaultValues?: T | T[],\r\n              initialSetters?: string[],\r\n              baseType?: new () => T) {\r\n    super(\r\n      extend<any>(DEFAULT_VALUES, defaultValues || {}),\r\n      arrayUnion<string>(DEFAULT_SETTERS, initialSetters || []),\r\n      baseType || <any>OverlayContext // https://github.com/Microsoft/TypeScript/issues/7234\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Returns an new OverlayConfig with a context property representing the data in this builder.\r\n   * @param base A base configuration that the result will extend\r\n   */\r\n  toOverlayConfig(base?: OverlayConfig): OverlayConfig {\r\n    return extend(base || {}, {\r\n      context: this.toJSON()\r\n    });\r\n  }\r\n}\r\n\r\nexport interface ModalControllingContextBuilder<T> {\r\n  open(viewContainer?: WideVCRef): DialogRef<T>;\r\n}\r\n\r\n/**\r\n * A helper to create an `OverlayConfig` on the fly.\r\n * Since `OverlayConfig` requires context it means a builder is needed, this process had some boilerplate.\r\n * When a quick, on the fly overlay config is needed use this helper to avoid that boilerplate.\r\n *\r\n * A builder is used as an API to allow setting the context and providing some operations around the modal.\r\n * When a developers knows the context before hand we can skip this step, this is what this factory is for.\r\n *\r\n * @param context The context for the modal\r\n * @param baseContextType Optional. The type/class of the context. This is the class used to init a new instance of the context\r\n * @param baseConfig A base configuration that the result will extend\r\n */\r\nexport function overlayConfigFactory<T>(context: T, baseContextType?: any, baseConfig?: OverlayConfig): OverlayConfig {\r\n  return new OverlayContextBuilder<T & OverlayContext>(<any>context, undefined, baseContextType).toOverlayConfig(baseConfig);\r\n}\r\n"]}