@c8y/ngx-components
Version:
Angular modules for Cumulocity IoT applications
88 lines • 22.3 kB
JavaScript
import { InjectionToken } from '@angular/core';
import { hookGeneric } from '../common/extension-hooks';
/**
* Time the hook waits until it emits an undefined value.
* Used for not defined widgets -> by default after 5s we
* show an error that the widget could not be loaded.
*/
export const RESOLVING_COMPONENT_WAIT_TIME = new InjectionToken('RESOLVING_COMPONENT_WAIT_TIME');
/**
* A hook to add dynamic components to the UI (e.g. widgets).
* @deprecated Consider using the `hookComponent` function instead.
*/
export const HOOK_COMPONENTS = new InjectionToken('HOOK_COMPONENTS');
/**
* A hook to add dynamic components to the UI (e.g. widgets).
*
* You can either provide a single `DynamicComponentDefinition` as parameter:
* ```typescript
* hookComponent(...)
* ```
*
* Or an array to directly register multiple:
* ```typescript
* hookComponent([...])
* ```
*
* Or you provide an Service that implements `ExtensionFactory<DynamicComponentDefinition>`
* ```typescript
* export class MyDynamicComponentDefinitionFactory implements ExtensionFactory<DynamicComponentDefinition> {...}
* ...
* hookComponent(MyDynamicComponentDefinitionFactory)
* ```
* A typed alternative to `HOOK_COMPONENTS`.
* @param components The `DynamicComponentDefinition`'s or `ExtensionFactory` to be provided.
* @returns An `Provider` to be provided in your module.
*/
export function hookComponent(components, options) {
return hookGeneric(components, HOOK_COMPONENTS, options);
}
/**
* Hook to add dynamic widget components to the UI.
*
* You can either provide a single `DynamicWidgetDefinition` as parameter:
* ```typescript
* hookWidget(...)
* ```
*
* Or an array to directly register multiple:
* ```typescript
* hookWidget([...])
* ```
*
* * Or you provide a Service that implements `ExtensionFactory<DynamicWidgetDefinition>`
* ```typescript
* export class MyDynamicWidgetDefinitionFactory implements ExtensionFactory<DynamicWidgetDefinition> {...}
* ...
* hookWidget(MyDynamicWidgetDefinitionFactory)
* ```
* A widget specific alternative to `hookComponent`..
* @param components The `DynamicWidgetDefinition`'s or `ExtensionFactory` to be provided.
* @param options Options to configure the hook.
* @returns An `Provider` to be provided in your module.
*/
export function hookWidget(components, options) {
return hookComponent(components, options);
}
export function isLazyDynamicComponents(componentDefinition) {
return !!componentDefinition?.loadComponent;
}
export function isEagerDynamicComponents(componentDefinition) {
return !!componentDefinition?.component;
}
export var DynamicComponentErrorStrategy;
(function (DynamicComponentErrorStrategy) {
/**
* Will not render/initialize the Widget in case an error was detected.
*/
DynamicComponentErrorStrategy["NOT_RENDER"] = "NOT_RENDER";
/**
* Will add an overlay over the Widget, displaying the error message.
*/
DynamicComponentErrorStrategy["OVERLAY_ERROR"] = "OVERLAY_ERROR";
/**
* The widget implements error handling on its own.
*/
DynamicComponentErrorStrategy["CUSTOM"] = "CUSTOM";
})(DynamicComponentErrorStrategy || (DynamicComponentErrorStrategy = {}));
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-component.model.js","sourceRoot":"","sources":["../../../../core/dynamic-component/dynamic-component.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAkB,MAAM,eAAe,CAAC;AAE/D,OAAO,EAIL,WAAW,EACZ,MAAM,2BAA2B,CAAC;AAKnC;;;;GAIG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,IAAI,cAAc,CAC7D,+BAA+B,CAChC,CAAC;AAyBF;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,cAAc,CAA8B,iBAAiB,CAAC,CAAC;AAElG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,aAAa,CAC3B,UAAuD,EACvD,OAAqC;IAErC,OAAO,WAAW,CAA6B,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;AACvF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,UAAU,CACxB,UAAoD,EACpD,OAAqC;IAErC,OAAO,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAC5C,CAAC;AA0OD,MAAM,UAAU,uBAAuB,CACrC,mBAAsC;IAEtC,OAAO,CAAC,CAAC,mBAAmB,EAAE,aAAa,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,wBAAwB,CACtC,mBAAsC;IAEtC,OAAO,CAAC,CAAC,mBAAmB,EAAE,SAAS,CAAC;AAC1C,CAAC;AAED,MAAM,CAAN,IAAY,6BAaX;AAbD,WAAY,6BAA6B;IACvC;;OAEG;IACH,0DAAyB,CAAA;IACzB;;OAEG;IACH,gEAA+B,CAAA;IAC/B;;OAEG;IACH,kDAAiB,CAAA;AACnB,CAAC,EAbW,6BAA6B,KAA7B,6BAA6B,QAaxC","sourcesContent":["import { InjectionToken, Injector, Type } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport {\n  ExtensionFactory,\n  GenericHookOptions,\n  GenericHookType,\n  hookGeneric\n} from '../common/extension-hooks';\nimport { DynamicComponentAlertAggregator } from './dynamic-component-alert-aggregator';\nimport { DynamicDetailsResolver } from './dynamic-details-resolver';\nimport { JSONSchema7 } from 'json-schema';\n\n/**\n * Time the hook waits until it emits an undefined value.\n * Used for not defined widgets -> by default after 5s we\n * show an error that the widget could not be loaded.\n */\nexport const RESOLVING_COMPONENT_WAIT_TIME = new InjectionToken<number>(\n  'RESOLVING_COMPONENT_WAIT_TIME'\n);\n\n/**\n * An extension HOOK can use either a pure value:\n * ```typescript\n *  { provide: HOOK_X, useValue: { ...hookValue }, multi: true }\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }\n * ```\n *\n * Or an ExtensionFactory which allows to define a get() function. This function\n * gets called on each navigation with the current route and can return values\n * async (observable or promise).\n * ```typescript\n *  { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }\n * ```\n */\nexport type DynamicComponentExtension =\n  | DynamicComponentDefinition\n  | DynamicComponentDefinition[]\n  | ExtensionFactory<DynamicComponentDefinition>;\n\n/**\n * A hook to add dynamic components to the UI (e.g. widgets).\n * @deprecated Consider using the `hookComponent` function instead.\n */\nexport const HOOK_COMPONENTS = new InjectionToken<DynamicComponentExtension[]>('HOOK_COMPONENTS');\n\n/**\n * A hook to add dynamic components to the UI (e.g. widgets).\n *\n * You can either provide a single `DynamicComponentDefinition` as parameter:\n * ```typescript\n *  hookComponent(...)\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  hookComponent([...])\n * ```\n *\n * Or you provide an Service that implements `ExtensionFactory<DynamicComponentDefinition>`\n * ```typescript\n *  export class MyDynamicComponentDefinitionFactory implements ExtensionFactory<DynamicComponentDefinition> {...}\n *  ...\n *  hookComponent(MyDynamicComponentDefinitionFactory)\n * ```\n * A typed alternative to `HOOK_COMPONENTS`.\n * @param components The `DynamicComponentDefinition`'s or `ExtensionFactory` to be provided.\n * @returns An `Provider` to be provided in your module.\n */\nexport function hookComponent(\n  components: GenericHookType<DynamicComponentDefinition>,\n  options?: Partial<GenericHookOptions>\n) {\n  return hookGeneric<DynamicComponentDefinition>(components, HOOK_COMPONENTS, options);\n}\n\n/**\n * Hook to add dynamic widget components to the UI.\n *\n * You can either provide a single `DynamicWidgetDefinition` as parameter:\n * ```typescript\n *  hookWidget(...)\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  hookWidget([...])\n * ```\n *\n *  * Or you provide a Service that implements `ExtensionFactory<DynamicWidgetDefinition>`\n * ```typescript\n *  export class MyDynamicWidgetDefinitionFactory implements ExtensionFactory<DynamicWidgetDefinition> {...}\n *  ...\n *  hookWidget(MyDynamicWidgetDefinitionFactory)\n * ```\n * A widget specific alternative to `hookComponent`..\n * @param components The `DynamicWidgetDefinition`'s or `ExtensionFactory` to be provided.\n * @param options Options to configure the hook.\n * @returns An `Provider` to be provided in your module.\n */\nexport function hookWidget(\n  components: GenericHookType<DynamicWidgetDefinition>,\n  options?: Partial<GenericHookOptions>\n) {\n  return hookComponent(components, options);\n}\n\n/**\n * A dynamic component can be defined in a the HOOK_COMPONENTS to display any kind\n * of component dynamically just by referencing it's id. The most common use case is on dashboards,\n * where the `configComponent` is used to define what is displayed on the `component`\n * on the dashboard.\n *\n * To use the component you can use the c8y-dynamic-component.\n *\n * ```\n *   <c8y-dynamic-component\n *     componentId=\"angular.widget.demo\"\n *     [config]=\"{ text: 'Hello world' }\"\n *     [mode]=\"editComponent ? 'config' : 'component'\"\n *   ></c8y-dynamic-component>\n *   ```\n */\nexport type DynamicComponentDefinition = DynamicComponentDefinitionBase & DynamicComponents;\n\nexport type DynamicWidgetDefinition = DynamicWidgetDefinitionBase & DynamicComponents;\n\nexport interface DynamicComponentDefinitionBase extends DefinitionBase {\n  /**\n   * Add any random data, specially to angular.js dashboards.\n   * Should be serializable to allow to save it to the API.\n   */\n  data?: any;\n}\n\nexport interface DynamicWidgetDefinitionBase extends DefinitionBase {\n  /**\n   * Add any random data, specially to angular.js dashboards.\n   * Should be serializable to allow to save it to the API.\n   */\n  data?: WidgetDataType;\n}\n\nexport interface DefinitionBase {\n  /**\n   * Unique serializable id\n   */\n  id: string;\n  /**\n   * The label shown for this dynamic component on add widgets\n   */\n  label: string;\n  /**\n   * The description shown on add widget\n   */\n  description: string;\n  /**\n   * Add any random data, specially to angular.js dashboards.\n   * Should be searilzabled to allow to save it to the API.\n   */\n  data?: any;\n  /**\n   * An url to an preview image.\n   */\n  previewImage?: string;\n  /**\n   * The injector to use to inject this component. If used in a module federation\n   * plugin, the injector of the plugin should be used. Defaults to the root injector.\n   */\n  injector?: Injector;\n  /**\n   * Attributes of the dynamic components configuration to be resolved.\n   */\n  resolve?: { [key: string]: Type<DynamicDetailsResolver> };\n  /**\n   * Determines if dynamic component or widget itself should render alerts.\n   */\n  errorStrategy?: DynamicComponentErrorStrategy;\n  /**\n   * Ordering of the components\n   */\n  priority?: number;\n}\n\ntype WidgetDisplaySettingsCore = {\n  /**\n   * If enabled the widget is bound to the global time context. You can listen to ngOnChanges() change detection\n   * to react to changes on the context. When a more detailed configuration is needed, use the <c8y-widget-time-context>\n   * component instead.\n   */\n  globalTimeContext?: boolean;\n  /**\n   * If enabled the widget is bound to the global realtime context. You can listen to ngOnChanges() change detection\n   * to react to changes on the context.\n   */\n  globalRealtimeContext?: boolean;\n  /**\n   * If enabled the widget is bound to the global aggregation context. You can listen to ngOnChanges() change detection\n   * to react to changes on the context.\n   */\n  globalAggregationContext?: boolean;\n  globalAutoRefreshContext?: boolean;\n};\n\nexport interface WidgetDataType {\n  /**\n   * Settings that define the context to which the widget is bound.\n   * E.g. global time context, global realtime context, global aggregation context.\n   */\n  displaySettings?: WidgetDisplaySettingsCore;\n  /**\n   * Settings that are used to configure the widget.\n   * They are static and will not be saved.\n   */\n  settings?: WidgetSettings;\n  /**\n   * Callback to get the schema for the widget e.g. for widget config JSON validation purposes in runtime.\n   * In order to use this feature, schema should contain `c8y-schema-loader` prefix, interface name as param\n   * and path to file where interface is defined to match \"c8y-schema-loader?interfaceName=<interface name>!<path to file>\".\n   * ```ts\n   * // schema: () => import('c8y-schema-loader?interfaceName=KpiWidgetConfig!@c8y/ngx-components/widgets/implementations/kpi')\n   * ```\n   * Schema will be generated in build process and will be available in runtime.\n   */\n  schema?: () => Promise<{ schema: JSONSchema7 }>;\n}\n\nexport interface WidgetSettings {\n  /**\n   * Avoids to show the widget in the \"add widget\" modal\n   */\n  noNewWidgets?: boolean;\n  upgrade?: boolean;\n  widgetDefaults?: {\n    _width?: number;\n    _height?: number;\n    [key: string]: any;\n  };\n  ng1?: {\n    options?: {\n      /**\n       * Set this to false, to hide the device/group selector\n       * @deprecated: This is currently only implemented in angularjs and will be exported to a separate component.\n       */\n      noDeviceTarget?: boolean;\n      /**\n       * Set this to false to only select devices\n       * @deprecated: This is currently only implemented in angularjs and will be exported to a separate component.\n       */\n      groupsSelectable?: boolean;\n      [key: string]: any;\n    };\n    /**\n     * The context from the device selector.\n     */\n    context?: {\n      id?: string;\n      name?: string;\n      [key: string]: any;\n    };\n    [key: string]: any;\n  };\n  /**\n   * Additional settings for the widget.\n   */\n  [key: string]: any;\n}\n\nexport interface AngularJSWidgetSettings extends WidgetSettings {\n  /**\n   * The config component name.\n   * @deprecated: Only used for angularjs plugins.\n   */\n  configComponent?: string;\n  /**\n   * The widget component name.\n   * @deprecated: Only used for angularjs plugins.\n   */\n  widgetComponent?: string;\n  /**\n   * The config template URL for legacy plugins.\n   * @deprecated: Only used for angularjs plugins.\n   */\n  configTemplateUrl?: string;\n  /**\n   * Transforms widget's config by executing transform function.\n   * The transform function can take injectable arguments\n   * @deprecated: Only used for angularjs plugins.\n   */\n  transformConfigWithContext?: () => void;\n  /**\n   * Avoids to show the widget in the \"add widget\" modal\n   */\n}\n\nexport type DynamicComponents = EagerDynamicComponents | LazyDynamicComponents;\n\nexport interface EagerDynamicComponents {\n  /**\n   * The component which is used when the component should be displayed (e.g. on a dashboard)\n   */\n  component: Type<any>;\n  loadComponent?: never;\n  /**\n   * The configuration component used when a widget is added or edited.\n   */\n  configComponent?: Type<any>;\n  loadConfigComponent?: never;\n}\n\nexport interface LazyDynamicComponents {\n  /**\n   * A function returning a promise of the component which is used when the component should be displayed (e.g. on a dashboard)\n   *\n   * A sample function to be provided could look like this:\n   * ```\n   * async function loadViewComponent() {\n   *  const { LazyWidgetViewComponent } = await import('./lazy-widget-view');\n   *  return LazyWidgetViewComponent;\n   * }\n   * ```\n   */\n  loadComponent: () => Promise<Type<any>>;\n  component?: never;\n  /**\n   * A function returning a promise of the configuration component used when a widget is added or edited.\n   *\n   * A sample function to be provided could look like this:\n   * ```\n   * async function loadConfigComponent() {\n   *  const { LazyWidgetConfigComponent } = await import('./lazy-widget-config');\n   *  return LazyWidgetConfigComponent;\n   * }\n   * ```\n   */\n  loadConfigComponent?: () => Promise<Type<any>>;\n  configComponent?: never;\n}\n\nexport function isLazyDynamicComponents(\n  componentDefinition: DynamicComponents\n): componentDefinition is LazyDynamicComponents {\n  return !!componentDefinition?.loadComponent;\n}\n\nexport function isEagerDynamicComponents(\n  componentDefinition: DynamicComponents\n): componentDefinition is EagerDynamicComponents {\n  return !!componentDefinition?.component;\n}\n\nexport enum DynamicComponentErrorStrategy {\n  /**\n   * Will not render/initialize the Widget in case an error was detected.\n   */\n  NOT_RENDER = 'NOT_RENDER',\n  /**\n   * Will add an overlay over the Widget, displaying the error message.\n   */\n  OVERLAY_ERROR = 'OVERLAY_ERROR',\n  /**\n   * The widget implements error handling on its own.\n   */\n  CUSTOM = 'CUSTOM'\n}\n\n/**\n * Use this interface on any component to define the interchange between\n * config and display component.\n */\nexport interface DynamicComponent {\n  /**\n   * The configuration which is shared between configuration component and display component.\n   * Should be searilzabled to allow to save it to the API.\n   */\n  config: any;\n  /**\n   * Alerts related to the dynamic component.\n   * Can either be set by the dynamic component it self or via it's resolvers.\n   */\n  alerts?: DynamicComponentAlertAggregator;\n  /**\n   * A reference to the ng1Form on angularjs dashboards to disable/enable the save button.\n   * @deprecated: Will not work on Angular-Dashboards (1.6.1.0). Use `ContextServiceDashboard.formDisabled` instead.\n   */\n  ng1FormRef?: any;\n}\n\n/**\n * An lifecycle hook which is called before an configuration is saved.\n */\nexport interface OnBeforeSave {\n  /**\n   * Called before a configuration object is saved. The function can be used to manipulate the\n   * passed config object or to cancel the saving (return false or Observable<boolean>).\n   */\n  onBeforeSave(config?: any): boolean | Promise<boolean> | Observable<boolean>;\n}\n"]}