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 parentLayerType () { return undefined; } // returns String
  35.     get geometryType () { return undefined; } // returns String
  36.     get featureCount () { return undefined; } // returns Integer
  37.     get extent () { return undefined; } // returns Object (Esri Extent)
  39.     // layer states
  40.     get state () { return undefined; } // returns String
  42.     // these return the current values of the corresponding controls
  43.     get visibility () { return undefined; } // returns Boolean
  44.     get opacity () { return undefined; } // returns Decimal
  45.     get query () { return undefined; } // returns Boolean
  46.     get snapshot () { return undefined; } // returns Boolean
  47.     get highlightFeature () { return undefined; } // returns Boolean
  49.     // fetches attributes for use in the datatable
  50.     get formattedAttributes () { return undefined; } // returns Promise of Object
  52.     // returns a feature name of an attribute set
  53.     getFeatureName () { return undefined; } // returns String
  55.     // formats an attribute to standard details
  56.     attributesToDetails () { return undefined; } // returns Array
  58.     // these set values to the corresponding controls
  60.     // param: boolean
  61.     setVisibility () { return undefined; }
  63.     // param: numeric (between 0 and 1)
  64.     setOpacity () { return undefined; }
  66.     // param: boolean
  67.     setQuery () { return undefined; }
  69.     // param: integer, boolean (optional)
  70.     fetchGraphic () { return undefined; } // returns promise that resolves with object containing graphics info
  72.     // param: esriMap
  73.     zoomToBoundary () { return undefined; } // returns promise that resolves after zoom completes
  75.     // param: esriMap, array of lods, boolean, optional boolean
  76.     zoomToScale () { return undefined; } // returns promise that resolves after zoom completes
  78.     // param: Integer, esriMap, Object {x: Numeric, y: Numeric}
  79.     zoomToGraphic () { return undefined; } // returns promise that resolves after zoom completes
  81.     // param: string
  82.     setDefinitionQuery () { return undefined; }
  84.     // param: spatialReference object
  85.     validateProjection () { return undefined; } // returns Boolean
  87.     // param: integer
  88.     isOffScale () { return undefined; } // returns Object {offScale: Boolean, zoomIn: Boolean}
  90.     // updates what this interface is pointing to, in terms of layer data source.
  91.     // often, the interface starts with a placeholder to avoid errors and return
  92.     // defaults. This update happens after a layer has loaded, and new now want
  93.     // the interface reading off the real FC.
  94.     // TODO docs
  95.     updateSource (newSource) {
  96.         this._source = newSource;
  97.     }
  99.     convertToSingleLayer (layerRecord) {
  100.         this._source = layerRecord;
  101.         this._isPlaceholder = false;
  103.         newProp(this, 'symbology', standardGetSymbology);
  104.         newProp(this, 'state', standardGetState);
  106.         newProp(this, 'visibility', standardGetVisibility);
  107.         newProp(this, 'opacity', standardGetOpacity);
  108.         newProp(this, 'query', standardGetQuery);
  110.         newProp(this, 'name', standardGetName);
  112.         newProp(this, 'geometryType', standardGetGeometryType);
  113.         newProp(this, 'layerType', standardGetLayerType);
  114.         newProp(this, 'parentLayerType', standardGetParentLayerType);
  115.         newProp(this, 'featureCount', standardGetFeatureCount);
  116.         newProp(this, 'extent', standardGetExtent);
  118.         this.setVisibility = standardSetVisibility;
  119.         this.setOpacity = standardSetOpacity;
  120.         this.setQuery = standardSetQuery;
  121.         this.zoomToBoundary = standardZoomToBoundary;
  122.         this.validateProjection = standardValidateProjection;
  123.         this.zoomToScale = standardZoomToScale;
  124.         this.isOffScale = standardIsOffScale;
  125.     }
  127.     convertToFeatureLayer (layerRecord) {
  128.         this.convertToSingleLayer(layerRecord);
  130.         newProp(this, 'snapshot', featureGetSnapshot);
  131.         newProp(this, 'formattedAttributes', standardGetFormattedAttributes);
  132.         newProp(this, 'geometryType', featureGetGeometryType);
  133.         newProp(this, 'featureCount', featureGetFeatureCount);
  134.         newProp(this, 'highlightFeature', featureGetHighlightFeature);
  136.         this.getFeatureName = featureGetFeatureName;
  137.         this.attributesToDetails = featureAttributesToDetails;
  138.         this.fetchGraphic = featureFetchGraphic;
  139.         this.setDefinitionQuery = featureSetDefinitionQuery;
  140.         this.zoomToGraphic = featureZoomToGraphic;
  141.     }
  143.     convertToDynamicLeaf (dynamicFC) {
  144.         this._source = dynamicFC;
  145.         this._isPlaceholder = false;
  147.         newProp(this, 'symbology', dynamicLeafGetSymbology);
  148.         newProp(this, 'state', dynamicLeafGetState);
  150.         newProp(this, 'name', dynamicLeafGetName);
  152.         newProp(this, 'visibility', dynamicLeafGetVisibility);
  153.         newProp(this, 'opacity', dynamicLeafGetOpacity);
  154.         newProp(this, 'query', dynamicLeafGetQuery);
  155.         newProp(this, 'formattedAttributes', dynamicLeafGetFormattedAttributes);
  157.         newProp(this, 'geometryType', dynamicLeafGetGeometryType);
  158.         newProp(this, 'layerType', dynamicLeafGetLayerType);
  159.         newProp(this, 'parentLayerType', dynamicLeafGetParentLayerType);
  160.         newProp(this, 'featureCount', dynamicLeafGetFeatureCount);
  161.         newProp(this, 'extent', dynamicLeafGetExtent);
  163.         newProp(this, 'highlightFeature', dynamicLeafGetHighlightFeature);
  165.         this.setVisibility = dynamicLeafSetVisibility;
  166.         this.setOpacity = dynamicLeafSetOpacity;
  167.         this.setQuery = dynamicLeafSetQuery;
  168.         this.zoomToBoundary = dynamicLeafZoomToBoundary;
  169.         this.zoomToScale = dynamicLeafZoomToScale;
  170.         this.getFeatureName = featureGetFeatureName;
  171.         this.attributesToDetails = dynamicLeafAttributesToDetails;
  172.         this.fetchGraphic = dynamicLeafFetchGraphic;
  173.         this.setDefinitionQuery = dynamicLeafSetDefinitionQuery;
  174.         this.isOffScale = dynamicLeafIsOffScale;
  175.         this.zoomToGraphic = dynamicLeafZoomToGraphic;
  176.     }
  178.     convertToPlaceholder (placeholderFC) {
  179.         this._source = placeholderFC;
  180.         this._isPlaceholder = true;
  182.         newProp(this, 'symbology', standardGetSymbology);
  183.         newProp(this, 'name', standardGetName);
  184.         newProp(this, 'state', standardGetState);
  185.         newProp(this, 'layerType', standardGetLayerType);
  186.         newProp(this, 'parentLayerType', standardGetParentLayerType);
  187.     }
  189.     // TODO we might need a `converToDynamicLayer`. It calls `converToSingleLayer` and then
  190.     //      removes zoomToScale method, as this method will fail if called directly on a
  191.     //      dynamic layer proxy. As is, nothing should ever make that call. But we can
  192.     //      do this to be safe.
  194. }
  196. /**
  197.  * Worker function to add or override a get property on an object
  198.  *
  199.  * @function newProp
  200.  * @private
  201.  * @param {Object} target     the object that will receive the new property
  202.  * @param {String} propName   name of the get property
  203.  * @param {Function} getter   the function defining the guts of the get property.
  204.  */
  205. function newProp(target, propName, getter) {
  206.     Object.defineProperty(target, propName, {
  207.         get: getter,
  208.         enumerable: true,
  209.         configurable: true
  210.     });
  211. }
  213. // these functions are upgrades to the duds above.
  214. // we don't use arrow notation, as we want the `this` to point at the object
  215. // that these functions get smashed into.
  217. function standardGetState() {
  218.     /* jshint validthis: true */
  219.     return this._source.state;
  220. }
  222. function dynamicLeafGetState() {
  223.     /* jshint validthis: true */
  224.     return this._source.state;
  225. }
  227. function standardGetVisibility() {
  228.     /* jshint validthis: true */
  229.     return this._source.visibility;
  230. }
  232. function dynamicLeafGetVisibility() {
  233.     /* jshint validthis: true */
  234.     return this._source.getVisibility();
  235. }
  237. function standardGetName() {
  238.     /* jshint validthis: true */
  239.     return this._source.name;
  240. }
  242. function dynamicLeafGetName() {
  243.     /* jshint validthis: true */
  244.     return this._source.name;
  245. }
  247. function standardGetOpacity() {
  248.     /* jshint validthis: true */
  249.     return this._source.opacity;
  250. }
  252. function dynamicLeafGetOpacity() {
  253.     /* jshint validthis: true */
  254.     return this._source.opacity;
  255. }
  257. function standardGetLayerType() {
  258.     /* jshint validthis: true */
  259.     return this._source.layerType;
  260. }
  262. function dynamicLeafGetLayerType() {
  263.     /* jshint validthis: true */
  264.     return this._source.layerType;
  265. }
  267. function standardGetParentLayerType() {
  268.     /* jshint validthis: true */
  269.     return this._source.parentLayerType;
  270. }
  272. function dynamicLeafGetParentLayerType() {
  273.     /* jshint validthis: true */
  274.     return this._source.parentLayerType;
  275. }
  277. function standardGetExtent() {
  278.     /* jshint validthis: true */
  279.     return this._source.extent;
  280. }
  282. function dynamicLeafGetExtent() {
  283.     /* jshint validthis: true */
  284.     return this._source.extent;
  285. }
  287. function standardGetQuery() {
  288.     /* jshint validthis: true */
  289.     return this._source.isQueryable();
  290. }
  292. function dynamicLeafGetQuery() {
  293.     /* jshint validthis: true */
  294.     return this._source.queryable;
  295. }
  297. function standardGetFormattedAttributes() {
  298.     /* jshint validthis: true */
  300.     return this._source.getFormattedAttributes();
  301. }
  303. function dynamicLeafGetFormattedAttributes() {
  304.     /* jshint validthis: true */
  306.     // TODO code-wise this looks identical to standardGetFormattedAttributes.
  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.getFormattedAttributes();
  310. }
  312. function standardGetSymbology() {
  313.     /* jshint validthis: true */
  314.     return this._source.symbology;
  315. }
  317. function dynamicLeafGetSymbology() {
  318.     /* jshint validthis: true */
  320.     // TODO code-wise this looks identical to standardGetSymbology.
  321.     //      however in this case, ._source is a DynamicFC, not a LayerRecord.
  322.     //      This is safer. Deleting this would avoid the duplication. Decide.
  323.     return this._source.symbology;
  324. }
  326. function standardGetGeometryType() {
  327.     /* jshint validthis: true */
  328.     return undefined;
  329. }
  331. function featureGetGeometryType() {
  332.     /* jshint validthis: true */
  333.     return this._source.getGeomType();
  334. }
  336. function dynamicLeafGetGeometryType() {
  337.     /* jshint validthis: true */
  339.     // TEST STATUS none
  340.     return this._source.geomType;
  341. }
  343. function standardGetFeatureCount() {
  344.     /* jshint validthis: true */
  345.     return undefined;
  346. }
  348. function featureGetFeatureCount() {
  349.     /* jshint validthis: true */
  350.     return this._source.featureCount;
  351. }
  353. function dynamicLeafGetFeatureCount() {
  354.     /* jshint validthis: true */
  355.     return this._source.featureCount;
  356. }
  358. function standardSetVisibility(value) {
  359.     /* jshint validthis: true */
  360.     this._source.visibility = value;
  361. }
  363. function dynamicLeafSetVisibility(value) {
  364.     /* jshint validthis: true */
  365.     this._source.setVisibility(value);
  366. }
  368. function standardSetOpacity(value) {
  369.     /* jshint validthis: true */
  370.     this._source.opacity = value;
  371. }
  373. function dynamicLeafSetOpacity(value) {
  374.     /* jshint validthis: true */
  375.     this._source.opacity = value;
  376. }
  378. function standardSetQuery(value) {
  379.     /* jshint validthis: true */
  380.     this._source.setQueryable(value);
  381. }
  383. function dynamicLeafSetQuery(value) {
  384.     /* jshint validthis: true */
  385.     this._source.queryable = value;
  386. }
  388. function featureGetSnapshot() {
  389.     /* jshint validthis: true */
  390.     return this._source.isSnapshot;
  391. }
  393. function featureGetHighlightFeature() {
  394.     return true;
  395. }
  397. function dynamicLeafGetHighlightFeature() {
  398.     /* jshint validthis: true */
  399.     return this._source.highlightFeature;
  400. }
  402. function standardZoomToBoundary(map) {
  403.     /* jshint validthis: true */
  404.     this._source.zoomToBoundary(map);
  405. }
  407. function dynamicLeafZoomToBoundary(map) {
  408.     /* jshint validthis: true */
  409.     this._source.zoomToBoundary(map);
  410. }
  412. function standardZoomToScale(map, lods, zoomIn, positionOverLayer = true) {
  413.     /* jshint validthis: true */
  414.     return this._source.zoomToScale(map, lods, zoomIn, positionOverLayer);
  415. }
  417. function dynamicLeafZoomToScale(map, lods, zoomIn, positionOverLayer = true) {
  418.     /* jshint validthis: true */
  419.     return this._source.zoomToScale(map, lods, zoomIn, positionOverLayer);
  420. }
  422. function featureGetFeatureName(objId, attribs) {
  423.     /* jshint validthis: true */
  424.     return this._source.getFeatureName(objId, attribs);
  425. }
  427. function featureAttributesToDetails(attribs, fields) {
  428.     /* jshint validthis: true */
  429.     return this._source.attributesToDetails(attribs, fields);
  430. }
  432. function dynamicLeafAttributesToDetails(attribs, fields) {
  433.     /* jshint validthis: true */
  434.     return this._source._parent.attributesToDetails(attribs, fields);
  435. }
  437. function featureFetchGraphic(oid, ignoreLocal = false) {
  438.     /* jshint validthis: true */
  439.     return this._source.fetchGraphic(oid, ignoreLocal);
  440. }
  442. function dynamicLeafFetchGraphic(oid, ignoreLocal = false) {
  443.     /* jshint validthis: true */
  444.     return this._source.fetchGraphic(oid, ignoreLocal);
  445. }
  447. function featureZoomToGraphic(oid, map, offsetFraction) {
  448.     /* jshint validthis: true */
  449.     return this._source.zoomToGraphic(oid, map, offsetFraction);
  450. }
  452. function dynamicLeafZoomToGraphic(oid, map, offsetFraction) {
  453.     /* jshint validthis: true */
  454.     return this._source.zoomToGraphic(oid, map, offsetFraction);
  455. }
  457. function featureSetDefinitionQuery(query) {
  458.     /* jshint validthis: true */
  459.     this._source.setDefinitionQuery(query);
  460. }
  462. function dynamicLeafSetDefinitionQuery(query) {
  463.     /* jshint validthis: true */
  464.     this._source.setDefinitionQuery(query);
  465. }
  467. function standardValidateProjection(spatialReference) {
  468.      /* jshint validthis: true */
  469.     return this._source.validateProjection(spatialReference);
  470. }
  472. function standardIsOffScale(mapScale) {
  473.      /* jshint validthis: true */
  474.     return this._source.isOffScale(mapScale);
  475. }
  477. function dynamicLeafIsOffScale(mapScale) {
  478.      /* jshint validthis: true */
  479.     return this._source.isOffScale(mapScale);
  480. }
  482. module.exports = () => ({
  483.     LayerInterface
  484. });