layer/layerRec/layerInterface.js

  1. 'use strict';
  3. // Controls Interface class is used to provide something to the UI that it can bind to.
  4. // It helps the UI keep in line with the layer state.
  5. // Due to bindings, we cannot destroy & recreate an interface when a legend item
  6. // goes from 'Unknown Placeholder' to 'Specific Layer Type'. This means we cannot
  7. // do object heirarchies, as to go from PlaceholderInterface to FeatureLayerInterface
  8. // would require a new object. Instead, we have a class that exposes all possible
  9. // methods and properties as error throwing stubs. Then we replace those functions
  10. // with real ones once we know the flavour of interface we want.
  12. class LayerInterface {
  14.     /**
  15.      * @param {Object} source     object that provides info to the interface. usually a LayerRecord or FeatureClass
  16.      */
  17.     constructor (source) {
  18.         this._source = source;
  20.         // TODO revisit isPlaceholder after grand refactor
  21.         this._isPlaceholder = true;
  22.     }
  24.     get isPlaceholder () { return this._isPlaceholder; } // returns Boolean
  26.     // these expose ui controls available on the interface and indicate which ones are disabled
  27.     get symbology () { return undefined; } // returns Array
  29.     // can be group or node name
  30.     get name () { return undefined; } // returns String
  32.     // these are needed for the type flag
  33.     get layerType () { return undefined; } // returns String
  34.     get geometryType () { return undefined; } // returns String
  35.     get featureCount () { return undefined; } // returns Integer
  36.     get extent () { return undefined; } // returns Object (Esri Extent)
  38.     // layer states
  39.     get state () { return undefined; } // returns String
  41.     // these return the current values of the corresponding controls
  42.     get visibility () { return undefined; } // returns Boolean
  43.     get opacity () { return undefined; } // returns Decimal
  44.     get query () { return undefined; } // returns Boolean
  45.     get snapshot () { return undefined; } // returns Boolean
  46.     get highlightFeature () { return undefined; } // returns Boolean
  48.     // fetches attributes for use in the datatable
  49.     get formattedAttributes () { return undefined; } // returns Promise of Object
  51.     // returns a feature name of an attribute set
  52.     getFeatureName () { return undefined; } // returns String
  54.     // formats an attribute to standard details
  55.     attributesToDetails () { return undefined; } // returns Array
  57.     // these set values to the corresponding controls
  59.     // param: boolean
  60.     setVisibility () { return undefined; }
  62.     // param: numeric (between 0 and 1)
  63.     setOpacity () { return undefined; }
  65.     // param: boolean
  66.     setQuery () { return undefined; }
  68.     // param: integer, boolean (optional)
  69.     fetchGraphic () { return undefined; } // returns promise that resolves with object containing graphics info
  71.     // param: esriMap
  72.     zoomToBoundary () { return undefined; } // returns promise that resolves after zoom completes
  74.     // param: esriMap, array of lods, boolean, optional boolean
  75.     zoomToScale () { return undefined; } // returns promise that resolves after zoom completes
  77.     // param: Integer, esriMap, Object {x: Numeric, y: Numeric}
  78.     zoomToGraphic () { return undefined; } // returns promise that resolves after zoom completes
  80.     // param: string
  81.     setDefinitionQuery () { return undefined; }
  83.     // param: spatialReference object
  84.     validateProjection () { return undefined; } // returns Boolean
  86.     // param: integer
  87.     isOffScale () { return undefined; } // returns Object {offScale: Boolean, zoomIn: Boolean}
  89.     // updates what this interface is pointing to, in terms of layer data source.
  90.     // often, the interface starts with a placeholder to avoid errors and return
  91.     // defaults. This update happens after a layer has loaded, and new now want
  92.     // the interface reading off the real FC.
  93.     // TODO docs
  94.     updateSource (newSource) {
  95.         this._source = newSource;
  96.     }
  98.     convertToSingleLayer (layerRecord) {
  99.         this._source = layerRecord;
  100.         this._isPlaceholder = false;
  102.         newProp(this, 'symbology', standardGetSymbology);
  103.         newProp(this, 'state', standardGetState);
  105.         newProp(this, 'visibility', standardGetVisibility);
  106.         newProp(this, 'opacity', standardGetOpacity);
  107.         newProp(this, 'query', standardGetQuery);
  109.         newProp(this, 'name', standardGetName);
  111.         newProp(this, 'geometryType', standardGetGeometryType);
  112.         newProp(this, 'layerType', standardGetLayerType);
  113.         newProp(this, 'featureCount', standardGetFeatureCount);
  114.         newProp(this, 'extent', standardGetExtent);
  116.         this.setVisibility = standardSetVisibility;
  117.         this.setOpacity = standardSetOpacity;
  118.         this.setQuery = standardSetQuery;
  119.         this.zoomToBoundary = standardZoomToBoundary;
  120.         this.validateProjection = standardValidateProjection;
  121.         this.zoomToScale = standardZoomToScale;
  122.         this.isOffScale = standardIsOffScale;
  123.     }
  125.     convertToFeatureLayer (layerRecord) {
  126.         this.convertToSingleLayer(layerRecord);
  128.         newProp(this, 'snapshot', featureGetSnapshot);
  129.         newProp(this, 'formattedAttributes', standardGetFormattedAttributes);
  130.         newProp(this, 'geometryType', featureGetGeometryType);
  131.         newProp(this, 'featureCount', featureGetFeatureCount);
  132.         newProp(this, 'highlightFeature', featureGetHighlightFeature);
  134.         this.getFeatureName = featureGetFeatureName;
  135.         this.attributesToDetails = featureAttributesToDetails;
  136.         this.fetchGraphic = featureFetchGraphic;
  137.         this.setDefinitionQuery = featureSetDefinitionQuery;
  138.         this.zoomToGraphic = featureZoomToGraphic;
  139.     }
  141.     convertToDynamicLeaf (dynamicFC) {
  142.         this._source = dynamicFC;
  143.         this._isPlaceholder = false;
  145.         newProp(this, 'symbology', dynamicLeafGetSymbology);
  146.         newProp(this, 'state', dynamicLeafGetState);
  148.         newProp(this, 'name', dynamicLeafGetName);
  150.         newProp(this, 'visibility', dynamicLeafGetVisibility);
  151.         newProp(this, 'opacity', dynamicLeafGetOpacity);
  152.         newProp(this, 'query', dynamicLeafGetQuery);
  153.         newProp(this, 'formattedAttributes', dynamicLeafGetFormattedAttributes);
  155.         newProp(this, 'geometryType', dynamicLeafGetGeometryType);
  156.         newProp(this, 'layerType', dynamicLeafGetLayerType);
  157.         newProp(this, 'featureCount', dynamicLeafGetFeatureCount);
  158.         newProp(this, 'extent', dynamicLeafGetExtent);
  160.         newProp(this, 'highlightFeature', dynamicLeafGetHighlightFeature);
  162.         this.setVisibility = dynamicLeafSetVisibility;
  163.         this.setOpacity = dynamicLeafSetOpacity;
  164.         this.setQuery = dynamicLeafSetQuery;
  165.         this.zoomToBoundary = dynamicLeafZoomToBoundary;
  166.         this.zoomToScale = dynamicLeafZoomToScale;
  167.         this.getFeatureName = featureGetFeatureName;
  168.         this.attributesToDetails = dynamicLeafAttributesToDetails;
  169.         this.fetchGraphic = dynamicLeafFetchGraphic;
  170.         this.setDefinitionQuery = dynamicLeafSetDefinitionQuery;
  171.         this.isOffScale = dynamicLeafIsOffScale;
  172.         this.zoomToGraphic = dynamicLeafZoomToGraphic;
  173.     }
  175.     convertToPlaceholder (placeholderFC) {
  176.         this._source = placeholderFC;
  177.         this._isPlaceholder = true;
  179.         newProp(this, 'symbology', standardGetSymbology);
  180.         newProp(this, 'name', standardGetName);
  181.         newProp(this, 'state', standardGetState);
  182.         newProp(this, 'layerType', standardGetLayerType);
  183.     }
  185.     // TODO we might need a `converToDynamicLayer`. It calls `converToSingleLayer` and then
  186.     //      removes zoomToScale method, as this method will fail if called directly on a
  187.     //      dynamic layer proxy. As is, nothing should ever make that call. But we can
  188.     //      do this to be safe.
  190. }
  192. /**
  193.  * Worker function to add or override a get property on an object
  194.  *
  195.  * @function newProp
  196.  * @private
  197.  * @param {Object} target     the object that will receive the new property
  198.  * @param {String} propName   name of the get property
  199.  * @param {Function} getter   the function defining the guts of the get property.
  200.  */
  201. function newProp(target, propName, getter) {
  202.     Object.defineProperty(target, propName, {
  203.         get: getter,
  204.         enumerable: true,
  205.         configurable: true
  206.     });
  207. }
  209. // these functions are upgrades to the duds above.
  210. // we don't use arrow notation, as we want the `this` to point at the object
  211. // that these functions get smashed into.
  213. function standardGetState() {
  214.     /* jshint validthis: true */
  215.     return this._source.state;
  216. }
  218. function dynamicLeafGetState() {
  219.     /* jshint validthis: true */
  220.     return this._source.state;
  221. }
  223. function standardGetVisibility() {
  224.     /* jshint validthis: true */
  225.     return this._source.visibility;
  226. }
  228. function dynamicLeafGetVisibility() {
  229.     /* jshint validthis: true */
  230.     return this._source.getVisibility();
  231. }
  233. function standardGetName() {
  234.     /* jshint validthis: true */
  235.     return this._source.name;
  236. }
  238. function dynamicLeafGetName() {
  239.     /* jshint validthis: true */
  240.     return this._source.name;
  241. }
  243. function standardGetOpacity() {
  244.     /* jshint validthis: true */
  245.     return this._source.opacity;
  246. }
  248. function dynamicLeafGetOpacity() {
  249.     /* jshint validthis: true */
  250.     return this._source.opacity;
  251. }
  253. function standardGetLayerType() {
  254.     /* jshint validthis: true */
  255.     return this._source.layerType;
  256. }
  258. function dynamicLeafGetLayerType() {
  259.     /* jshint validthis: true */
  260.     return this._source.layerType;
  261. }
  263. function standardGetExtent() {
  264.     /* jshint validthis: true */
  265.     return this._source.extent;
  266. }
  268. function dynamicLeafGetExtent() {
  269.     /* jshint validthis: true */
  270.     return this._source.extent;
  271. }
  273. function standardGetQuery() {
  274.     /* jshint validthis: true */
  275.     return this._source.isQueryable();
  276. }
  278. function dynamicLeafGetQuery() {
  279.     /* jshint validthis: true */
  280.     return this._source.queryable;
  281. }
  283. function standardGetFormattedAttributes() {
  284.     /* jshint validthis: true */
  286.     return this._source.getFormattedAttributes();
  287. }
  289. function dynamicLeafGetFormattedAttributes() {
  290.     /* jshint validthis: true */
  292.     // TODO code-wise this looks identical to standardGetFormattedAttributes.
  293.     //      however in this case, ._source is a DynamicFC, not a LayerRecord.
  294.     //      This is safer. Deleting this would avoid the duplication. Decide.
  295.     return this._source.getFormattedAttributes();
  296. }
  298. function standardGetSymbology() {
  299.     /* jshint validthis: true */
  300.     return this._source.symbology;
  301. }
  303. function dynamicLeafGetSymbology() {
  304.     /* jshint validthis: true */
  306.     // TODO code-wise this looks identical to standardGetSymbology.
  307.     //      however in this case, ._source is a DynamicFC, not a LayerRecord.
  308.     //      This is safer. Deleting this would avoid the duplication. Decide.
  309.     return this._source.symbology;
  310. }
  312. function standardGetGeometryType() {
  313.     /* jshint validthis: true */
  314.     return undefined;
  315. }
  317. function featureGetGeometryType() {
  318.     /* jshint validthis: true */
  319.     return this._source.getGeomType();
  320. }
  322. function dynamicLeafGetGeometryType() {
  323.     /* jshint validthis: true */
  325.     // TEST STATUS none
  326.     return this._source.geomType;
  327. }
  329. function standardGetFeatureCount() {
  330.     /* jshint validthis: true */
  331.     return undefined;
  332. }
  334. function featureGetFeatureCount() {
  335.     /* jshint validthis: true */
  336.     return this._source.featureCount;
  337. }
  339. function dynamicLeafGetFeatureCount() {
  340.     /* jshint validthis: true */
  341.     return this._source.featureCount;
  342. }
  344. function standardSetVisibility(value) {
  345.     /* jshint validthis: true */
  346.     this._source.visibility = value;
  347. }
  349. function dynamicLeafSetVisibility(value) {
  350.     /* jshint validthis: true */
  351.     this._source.setVisibility(value);
  352. }
  354. function standardSetOpacity(value) {
  355.     /* jshint validthis: true */
  356.     this._source.opacity = value;
  357. }
  359. function dynamicLeafSetOpacity(value) {
  360.     /* jshint validthis: true */
  361.     this._source.opacity = value;
  362. }
  364. function standardSetQuery(value) {
  365.     /* jshint validthis: true */
  366.     this._source.setQueryable(value);
  367. }
  369. function dynamicLeafSetQuery(value) {
  370.     /* jshint validthis: true */
  371.     this._source.queryable = value;
  372. }
  374. function featureGetSnapshot() {
  375.     /* jshint validthis: true */
  376.     return this._source.isSnapshot;
  377. }
  379. function featureGetHighlightFeature() {
  380.     return true;
  381. }
  383. function dynamicLeafGetHighlightFeature() {
  384.     /* jshint validthis: true */
  385.     return this._source.highlightFeature;
  386. }
  388. function standardZoomToBoundary(map) {
  389.     /* jshint validthis: true */
  390.     this._source.zoomToBoundary(map);
  391. }
  393. function dynamicLeafZoomToBoundary(map) {
  394.     /* jshint validthis: true */
  395.     this._source.zoomToBoundary(map);
  396. }
  398. function standardZoomToScale(map, lods, zoomIn, positionOverLayer = true) {
  399.     /* jshint validthis: true */
  400.     return this._source.zoomToScale(map, lods, zoomIn, positionOverLayer);
  401. }
  403. function dynamicLeafZoomToScale(map, lods, zoomIn, positionOverLayer = true) {
  404.     /* jshint validthis: true */
  405.     return this._source.zoomToScale(map, lods, zoomIn, positionOverLayer);
  406. }
  408. function featureGetFeatureName(objId, attribs) {
  409.     /* jshint validthis: true */
  410.     return this._source.getFeatureName(objId, attribs);
  411. }
  413. function featureAttributesToDetails(attribs, fields) {
  414.     /* jshint validthis: true */
  415.     return this._source.attributesToDetails(attribs, fields);
  416. }
  418. function dynamicLeafAttributesToDetails(attribs, fields) {
  419.     /* jshint validthis: true */
  420.     return this._source._parent.attributesToDetails(attribs, fields);
  421. }
  423. function featureFetchGraphic(oid, ignoreLocal = false) {
  424.     /* jshint validthis: true */
  425.     return this._source.fetchGraphic(oid, ignoreLocal);
  426. }
  428. function dynamicLeafFetchGraphic(oid, ignoreLocal = false) {
  429.     /* jshint validthis: true */
  430.     return this._source.fetchGraphic(oid, ignoreLocal);
  431. }
  433. function featureZoomToGraphic(oid, map, offsetFraction) {
  434.     /* jshint validthis: true */
  435.     return this._source.zoomToGraphic(oid, map, offsetFraction);
  436. }
  438. function dynamicLeafZoomToGraphic(oid, map, offsetFraction) {
  439.     /* jshint validthis: true */
  440.     return this._source.zoomToGraphic(oid, map, offsetFraction);
  441. }
  443. function featureSetDefinitionQuery(query) {
  444.     /* jshint validthis: true */
  445.     this._source.setDefinitionQuery(query);
  446. }
  448. function dynamicLeafSetDefinitionQuery(query) {
  449.     /* jshint validthis: true */
  450.     this._source.setDefinitionQuery(query);
  451. }
  453. function standardValidateProjection(spatialReference) {
  454.      /* jshint validthis: true */
  455.     return this._source.validateProjection(spatialReference);
  456. }
  458. function standardIsOffScale(mapScale) {
  459.      /* jshint validthis: true */
  460.     return this._source.isOffScale(mapScale);
  461. }
  463. function dynamicLeafIsOffScale(mapScale) {
  464.      /* jshint validthis: true */
  465.     return this._source.isOffScale(mapScale);
  466. }
  468. module.exports = () => ({
  469.     LayerInterface
  470. });