@conterra/ct-mapapps-typings 4.13.1 → 4.13.2-next.20220420041152

package/apprt-core/config.d.ts

@@ -14,6 +14,8 @@ export interface ConfigProperties {
     "ct-dgrid-touchscroll": boolean;
     /** True if content security policy settings prevent eval() etc. */
     "csp-restrictions": boolean;
+    /** True if WebAssembly is enabled. */
+    "webassembly": boolean;
     "touch": boolean;
     "mobile": boolean;
     "ie": number;
@@ -31,7 +33,7 @@ export declare type ConfigValue = undefined | null | boolean | number | string |
 declare type ValueProvider<T> = T | (() => T);
 /**
  * Returns the configuration value associated with the given key.
- * Throws an exception if the key is not known.
+ * Returns undefined if the key is not known.
  */
 export declare function config<K extends ConfigPropertyKey>(key: K): DeepReadonly<ConfigProperties[K]> | undefined;
 export default config;

package/coordinatetransformer/ProjectionEngineTransformerStrategy.d.ts

@@ -1,3 +1,4 @@
+export function isSupported(): boolean;
 export default class ProjectionEngineTransformerStrategy {
     init(opts: any): Promise<void>;
     transform: ((geometry: any, sourceSRS: any, targetSRS: any) => Promise<__esri.Geometry | __esri.Geometry[]>) | ((geometry: any, sourceSRS: any, targetSRS: any) => __esri.Geometry | __esri.Geometry[]) | undefined;
@@ -5,4 +6,3 @@ export default class ProjectionEngineTransformerStrategy {
     _transformAsync(geometry: any, sourceSRS: any, targetSRS: any): Promise<__esri.Geometry | __esri.Geometry[]>;
     #private;
 }
-export function isSupported(): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@conterra/ct-mapapps-typings",
-    "version": "4.13.1",
+    "version": "4.13.2-next.20220420041152",
     "description": "TypeDefinitions for ct-mapapps",
     "author": "conterra",
     "license": "Apache-2.0"

package/system/config/ConfigurationPlugin.d.ts

@@ -1,2 +1,84 @@
-declare var _default: any;
-export default _default;
+/**
+ * A service interface for processing configuration dictionary before the
+ * update.
+ *
+ * <p>
+ * A bundle registers a <code>ConfigurationPlugin</code> object in order to
+ * process configuration updates before they reach the Managed Service or
+ * Managed Service Factory. The Configuration Admin service will detect
+ * registrations of Configuration Plugin services and must call these services
+ * every time before it calls the <code>ManagedService</code> or
+ * <code>ManagedServiceFactory</code>
+ * <code>updated</code> method. The
+ * Configuration Plugin service thus has the opportunity to view and modify the
+ * properties before they are passed to the Managed Service or Managed Service
+ * Factory.
+ *
+ * <p>
+ * Configuration Plugin (plugin) services have full read/write access to all
+ * configuration information. Therefore, bundles using this facility should be
+ * trusted. Access to this facility should be limited with
+ * <code>ServicePermission[ConfigurationPlugin,REGISTER]</code>.
+ * Implementations of a Configuration Plugin service should assure that they
+ * only act on appropriate configurations.
+ *
+ * <p>
+ * The <code>Integer</code> <code>service.cmRanking</code> registration
+ * property may be specified. Not specifying this registration property, or
+ * setting it to something other than an <code>Integer</code>, is the same as
+ * setting it to the <code>Integer</code> zero. The
+ * <code>service.cmRanking</code> property determines the order in which
+ * plugins are invoked. Lower ranked plugins are called before higher ranked
+ * ones. In the event of more than one plugin having the same value of
+ * <code>service.cmRanking</code>, then the Configuration Admin service
+ * arbitrarily chooses the order in which they are called.
+ *
+ * <p>
+ * By convention, plugins with <code>service.cmRanking&lt; 0</code> or
+ * <code>service.cmRanking &gt; 1000</code> should not make modifications to
+ * the properties.
+ *
+ * <p>
+ * The Configuration Admin service has the right to hide properties from
+ * plugins, or to ignore some or all the changes that they make. This might be
+ * done for security reasons. Any such behavior is entirely implementation
+ * defined.
+ *
+ * <p>
+ * A plugin may optionally specify a <code>cm.target</code> registration
+ * property whose value is the PID of the Managed Service or Managed Service
+ * Factory whose configuration updates the plugin is intended to intercept. The
+ * plugin will then only be called with configuration updates that are targeted
+ * at the Managed Service or Managed Service Factory with the specified PID.
+ * Omitting the <code>cm.target</code> registration property means that the
+ * plugin is called for all configuration updates.
+ */
+export default class ConfigurationPlugin {
+    /**
+     * View and possibly modify the a set of configuration properties before
+     * they are sent to the Managed Service or the Managed Service Factory. The
+     * Configuration Plugin services are called in increasing order of their
+     * <code>service.cmRanking</code> property. If this property is undefined
+     * or is a non- <code>Integer</code> type, 0 is used.
+     *
+     * <p>
+     * This method should not modify the properties unless the
+     * <code>service.cmRanking</code> of this plugin is in the range
+     * <code>0 &lt;= service.cmRanking &lt;= 1000</code>.
+     * <p>
+     * If this method throws any <code>Exception</code>, the Configuration
+     * Admin service must catch it and should log it.
+     *
+     * @param targetInfo : {
+                            managedService : ..,
+                            managedServiceProperties: ..,
+                            pid: ..,
+                            factoryPid : ..
+                    }
+     * @param properties The configuration properties. This argument must not
+     *        contain the "service.bundleLocation" property. The value of this
+     *        property may be obtained from the
+     *        <code>Configuration.getBundleLocation</code> method.
+     */
+    modifyConfiguration(targetInfo: any, properties: any): void;
+}

package/system/config/ConfigurationStore.d.ts

@@ -1,2 +1,23 @@
-declare var _default: any;
-export default _default;
+declare const ConfigurationStore_base: any;
+/**
+ * Service for read/write configuration data.
+ * The store must currently be synchronous.
+ */
+export default class ConfigurationStore extends ConfigurationStore_base {
+    [x: string]: any;
+    _configs: any;
+    _factoryLookup: {};
+    searchConfigs(filter: any): any;
+    getFactoryConfigs(factoryPid: any): any[];
+    getConfig(pid: any): any;
+    /**
+     * Updates a configuration instance.
+     */
+    setConfig(pid: any, config: any): void;
+    /**
+     * Removes/deletes a configuration instance.
+     */
+    removeConfig(pid: any): void;
+    onConfigChanged(): void;
+}
+export {};

package/system/config/JSONConfigurationAdapter.d.ts

@@ -1,2 +1,36 @@
-declare var _default: any;
-export default _default;
+/**
+ * Provides a view from the config store to more human readable JSON structure.
+ *
+ * Service for read/write configuration data.
+ * The store must be synchronous.
+ */
+export default class JsonConfigurationAdapter {
+    activate(cpCtx: any): void;
+    _bundleContext: any;
+    jsonConfig: any;
+    appLocation: any;
+    deactivate(): void;
+    createInstance(): JsonConfigurationStore;
+    store: JsonConfigurationStore | null | undefined;
+    destroyInstance(): void;
+    _convertRootConfigToConfigStoreItems(jsonConfig: any, store: any): void;
+    _convertBundleConfigToStoreItems(bundleName: any, bundleConfigObj: any, store: any): void;
+    _convertComponentConfigToStoreItems(bundleName: any, componentName: any, componentProps: any, store: any): void;
+    _createStoreItem(isFactory: any, bundleName: any, componentName: any, props: any, facItemCounter: any): {
+        pid: any;
+        bundleIdentifier: any;
+        properties: any;
+    } | undefined;
+}
+declare class JsonConfigurationStore extends ConfigurationStore {
+    constructor(opts: any);
+    appLocation: any;
+    jsonConfig: any;
+    _bundleContext: any;
+    getAppConfig(): any;
+    save(): any;
+    _buildBundlesSectionFromStoreEntries(): {};
+    _persistEnabledState(jsonConfig: any): void;
+}
+import ConfigurationStore from "./ConfigurationStore";
+export {};

package/system/config/ManagedService.d.ts

@@ -1,2 +1,113 @@
-declare var _default: any;
-export default _default;
+/**
+ * A service that can receive configuration data from a Configuration Admin
+ * service.
+ *
+ * <p>
+ * A Managed Service is a service that needs configuration data. Such an object
+ * should be registered with the Framework registry with the
+ * <code>service.pid</code> property set to some unique identifier called a
+ * PID.
+ *
+ * <p>
+ * If the Configuration Admin service has a <code>Configuration</code> object
+ * corresponding to this PID, it will callback the <code>updated()</code>
+ * method of the <code>ManagedService</code> object, passing the properties of
+ * that <code>Configuration</code> object.
+ *
+ * <p>
+ * If it has no such <code>Configuration</code> object, then it calls back
+ * with a <code>null</code> properties argument. Registering a Managed Service
+ * will always result in a callback to the <code>updated()</code> method
+ * provided the Configuration Admin service is, or becomes active. This callback
+ * must always be done asynchronously.
+ *
+ * <p>
+ * Else, every time that either of the <code>updated()</code> methods is
+ * called on that <code>Configuration</code> object, the
+ * <code>ManagedService.updated()</code> method with the new properties is
+ * called. If the <code>delete()</code> method is called on that
+ * <code>Configuration</code> object, <code>ManagedService.updated()</code>
+ * is called with a <code>null</code> for the properties parameter. All these
+ * callbacks must be done asynchronously.
+ *
+ * <p>
+ * The following example shows the code of a serial port that will create a port
+ * depending on configuration information.
+ *
+ * <pre>
+ *
+ *   class SerialPort implements ManagedService {
+ *
+ *     ServiceRegistration registration;
+ *     Hashtable configuration;
+ *     CommPortIdentifier id;
+ *
+ *     synchronized void open(CommPortIdentifier id,
+ *     BundleContext context) {
+ *       this.id = id;
+ *       registration = context.registerService(
+ *         ManagedService.class.getName(),
+ *         this,
+ *         getDefaults()
+ *       );
+ *     }
+ *
+ *     Hashtable getDefaults() {
+ *       Hashtable defaults = new Hashtable();
+ *       defaults.put( &quot;port&quot;, id.getName() );
+ *       defaults.put( &quot;product&quot;, &quot;unknown&quot; );
+ *       defaults.put( &quot;baud&quot;, &quot;9600&quot; );
+ *       defaults.put( Constants.SERVICE_PID,
+ *         &quot;com.acme.serialport.&quot; + id.getName() );
+ *       return defaults;
+ *     }
+ *
+ *     public synchronized void updated(
+ *       Dictionary configuration  ) {
+ *       if ( configuration ==  null)
+ *         registration.setProperties( getDefaults() );
+ *       else {
+ *         setSpeed( configuration.get(&quot;baud&quot;) );
+ *         registration.setProperties( configuration );
+ *       }
+ *     }
+ *     ...
+ *   }
+ *
+ * </pre>
+ *
+ * <p>
+ * As a convention, it is recommended that when a Managed Service is updated, it
+ * should copy all the properties it does not recognize into the service
+ * registration properties. This will allow the Configuration Admin service to
+ * set properties on services which can then be used by other applications.
+ */
+export default class ManagedService {
+    /**
+     * Update the configuration for a Managed Service.
+     *
+     * <p>
+     * When the implementation of <code>updated(Dictionary)</code> detects any
+     * kind of error in the configuration properties, it should create a new
+     * <code>ConfigurationException</code> which describes the problem. This
+     * can allow a management system to provide useful information to a human
+     * administrator.
+     *
+     * <p>
+     * If this method throws any other <code>Exception</code>, the
+     * Configuration Admin service must catch it and should log it.
+     * <p>
+     * The Configuration Admin service must call this method asynchronously
+     * which initiated the callback. This implies that implementors of Managed
+     * Service can be assured that the callback will not take place during
+     * registration when they execute the registration in a synchronized method.
+     *
+     * @param properties A copy of the Configuration properties, or
+     *        <code>null</code>. This argument must not contain the
+     *        "service.bundleLocation" property. The value of this property may
+     *        be obtained from the <code>Configuration.getBundleLocation</code>
+     *        method.
+     * @throws ConfigurationException when the update fails
+     */
+    updated(properties: any): void;
+}

package/templatelayout/AppRootSizeController.d.ts

@@ -1,2 +1,10 @@
-declare var _default: any;
-export default _default;
+declare const AppRootSizeController_base: any;
+export default class AppRootSizeController extends AppRootSizeController_base {
+    [x: string]: any;
+    activate(): void;
+    resize(): void;
+    root: any;
+    _orientSize: {} | undefined;
+    deactivate(): void;
+}
+export {};

package/templatelayout/LayoutTemplateToolRuleProcessor.d.ts

@@ -1,2 +1,14 @@
-declare var _default: any;
-export default _default;
+/**
+ * LayoutTemplateToolRuleProcessor is a rule to match against the currently enabled sub-layout or layout template.
+ */
+export default class LayoutTemplateToolRuleProcessor {
+    ruleProperties: string[];
+    ruleContextState: null;
+    activate(): void;
+    /**
+     * Method is called by the ToolRule Manager.
+     */
+    isRuleFulfilled(tool: any, context: any, toolRuleDef: any): any[];
+    _matches(ruleNames: any, ruleValue: any, results: any): void;
+    _layoutStateChange(): void;
+}