const layout = layer.layout || {};

return (

(layer.type === 'circle' && layout['circle-animate-rings']) || // 动画点

layer.type === 'radar' || // 雷达图

layer.type === 'point-extrusion' || // 3D柱状图

layer.type === 'line-curve' || // OD

layer.type === 'line-curve-extrusion' || // OD-3D

layer.type === 'line-extrusion' || // 3D线

layer.type === 'chart' || // 统计专题图

(layer.type === 'heatmap' && layout['heatmap-shape']) || // L7-2D热力图

layer.type === 'heatmap-extrusion' || // L7-3D热力图

(layer.type === 'symbol' && layout['text-z-offset'] > 0)

);

if (!filter) {

return;

}

const [condition, ...expressions] = filter;

const newExpressions = expressions.filter((exp) => {

const [, f] = exp;

if (['$type', '$id'].includes(f)) {

return false;

}

return true;

});

const field = Array.from(new Set(getFilterFields(newExpressions)));

const fFilter = featureFilter([condition, ...newExpressions]);

const filterFunc = fFilter.filter.bind(fFilter);

return {

field,

values: (...args) => {

const properties = {};

field.forEach((f, idx) => {

properties[f] = args[idx];

});

const result = filterFunc(

{},

{

properties

}

);

return result;

}

};

const { featureFilter, expression, spec, L7Layer, L7, proj4 } = config;

/**

function addCredentialToUrl(url, credential) {

if (!credential) {

return url;

}

const tokenInfo = `${credential.key || credential.name}=${credential.value}`;

const newUrl = url.includes('?') ? `${url}&${tokenInfo}` : `${url}?${tokenInfo}`;

return newUrl;

}

/**

function getRestDataFields(datasetUrl, credential, options) {

const url = addCredentialToUrl(`${datasetUrl}/fields.json?returnAll=true`, credential);

return FetchRequest.get(url, null, options)

.then((res) => res.json())

.then((result) => {

return result.map((item) => {

const { caption, name, isSystemField, type, maxLength, isZeroLengthAllowed } = item;

return {

name,

type,

title: caption,

visible: true,

isSystemField,

maxLength, // MaxLength字节最大长度

isZeroLengthAllowed // 是否允许零长度

};

});

});

}

/**

function getRestDataDomains(datasetUrl, credential, options) {

const url = addCredentialToUrl(`${datasetUrl}/domain.json`, credential);

return FetchRequest.get(url, null, options).then((result) => {

return result.json();

});

}

/**

function sortRestdataField(fieldInfos) {

const systemFields = [];

const nonsystemFields = [];

fieldInfos.forEach((fieldInfo) => {

if (fieldInfo.isSystemField) {

systemFields.push(fieldInfo);

} else {

nonsystemFields.push(fieldInfo);

}

});

return systemFields.concat(nonsystemFields);

}

async function requestRestDataFieldsInfo(datasetUrl, credential, options) {

const [fields, domains] = await Promise.all([

getRestDataFields(datasetUrl, credential, options),

getRestDataDomains(datasetUrl, credential, options)

]);

domains.forEach((domain) => {

const { fieldName, type, rangeInfos, codeInfos } = domain;

const field = fields.find((item) => item.name === fieldName);

if (!field) {

return;

}

field.domain = {

type,

infos:

type === 'RANGE'

? rangeInfos.map((rangeInfo) => pickAttrs(rangeInfo, ['max', 'min', 'type']))

: codeInfos.map(({ value }) => value)

};

});

return sortRestdataField(fields);

}

/**

async function getRestDataFieldInfo(datasetUrl, credential, options) {

const fieldsInfos = await requestRestDataFieldsInfo(datasetUrl, credential, options);

return {

fieldNames: fieldsInfos.map((el) => el.name),

fieldTypes: fieldsInfos.map((el) => el.type)

};

}

/**

function transformFeatureField(properties, fields) {

return Object.keys(properties).reduce((result, k) => {

const newKey = fields.find((f) => f.toUpperCase() === k.toUpperCase());

newKey && (result[newKey] = properties[k]);

return result;

}, {});

}

/**

function getFieldTypeInfo(fields, fieldTypes) {

return (

fields &&

fields.reduce((pre, cur, idx) => {

pre[cur] = fieldTypes[idx];

return pre;

}, {})

);

}

/**

function isPortalNumberData(type) {

return [IPortalDataTypes.INT, IPortalDataTypes.LONG, IPortalDataTypes.DOUBLE].includes(type);

}

/**

function isRestDataNumberData(type) {

return [

RestDataTypes.DOUBLE,

RestDataTypes.INT16,

RestDataTypes.INT32,

RestDataTypes.INT64,

RestDataTypes.SINGLE

].includes(type);

}

function isNumberType(type) {

return isPortalNumberData(type) || isRestDataNumberData(type);

}

function transformDataType(type, value) {

const isNumber = isNumberType(type);

if (isNumber) {

return Number(value);

}

const isBoolean = type === propertyType.BOOLEAN;

if (isBoolean) {

return Boolean(value);

}

return value;

}

/**

function formatFeatures(features, fieldTypesInfo) {

return features.map((feature) => {

if (feature) {

for (const key in feature.properties) {

feature.properties[key] = transformDataType((fieldTypesInfo || {})[key], (feature.properties || {})[key]);

}

}

return feature;

});

}

/**

function transformFeaturesNameAndType(originFeatures, fieldNames, fieldTypes) {

const features = originFeatures.map((f) => {

return { ...f, properties: transformFeatureField(f.properties || {}, fieldNames) };

});

const fieldInfo = getFieldTypeInfo(fieldNames, fieldTypes);

return formatFeatures(features, fieldInfo);

}

function isIportalProxyServiceUrl(url, options) {

return options.iportalServiceProxyUrlPrefix && url.indexOf(options.iportalServiceProxyUrlPrefix) >= 0;

}

function handleWithRequestOptions(url, options) {

if (isIportalProxyServiceUrl(url, options)) {

return { ...options, withCredentials: true };

}

return { ...options, withCredentials: undefined };

}

/**

async function getRestDataGeojsonByWebMap(data, options) {

const { url, dataSourceName, datasetName, credential } = data;

const SQLParams = {

datasetNames: [dataSourceName + ':' + datasetName],

getFeatureMode: 'SQL',

targetEpsgCode: '4326',

queryParameter: { name: datasetName + '@' + dataSourceName }

};

const datasetUrl = `${url.split('featureResults')[0]}datasources/${dataSourceName}/datasets/${datasetName}`;

const nextOptions = handleWithRequestOptions(datasetUrl, options);

const { fieldNames, fieldTypes } = await getRestDataFieldInfo(datasetUrl, credential, nextOptions);

const nextUrl = addCredentialToUrl(url, credential);

const attrDataInfo = await FetchRequest.post(nextUrl, JSON.stringify(SQLParams), nextOptions);

const featuresRes = await attrDataInfo.json();

return {

type: 'FeatureCollection',

features: transformFeaturesNameAndType((featuresRes || {}).features || [], fieldNames, fieldTypes)

};

}

/**

function getStructDataItemJson(href, option) {

return FetchRequest.get(href, null, option)

.then((res) => res.json())

.then((data) => {

if (data.succeed === false) {

throw data.error.errorMsg;

}

return data;

});

}

/**

async function getStructDataItem(href, options) {

const data = await getStructDataItemJson(href, options);

const { features, links = [] } = data || {};

const nextInfo = links.find((l) => l.rel === 'next');

if (nextInfo) {

return features.concat(await getStructDataItem(nextInfo.href, options));

} else {

return features;

}

}

/**

async function getStructDataGeojson(datasetId, options) {

const href = `${options.server}web/datas/${datasetId}/structureddata/ogc-features/collections/all/items.json?limit=10000&offset=0`;

const allFeature = await getStructDataItem(href, options);

return {

type: 'FeatureCollection',

features: allFeature

};

}

/**

function transformCoordinate(fromProjection, toProjection, coordinates) {

if (fromProjection === toProjection) {

return coordinates;

}

// proj4缺陷，EPSG:4214的坐标x为180，转换后变成-179.

if (fromProjection === 'EPSG:4214' && toProjection === 'EPSG:4326' && coordinates[0] === 180) {

const newCoordinate = transformCoodinates({

coordinates,

sourceProjection: fromProjection,

destProjection: toProjection,

proj4

});

newCoordinate[0] = 180;

return newCoordinate;

}

return transformCoodinates({

coordinates,

sourceProjection: fromProjection,

destProjection: toProjection,

proj4

});

}

/**

function transformGeometryCoordinatesUtil(fromProjection, toProjection, geometry) {

if (geometry.type === 'MultiPolygon') {

const coordinates = geometry.coordinates;

const newGeometry = {

type: geometry.type,

coordinates: coordinates.map((items) => {

return items.map((item) => {

return item.map((c) => {

return transformCoordinate(fromProjection, toProjection, c);

});

});

})

};

return newGeometry;

}

if (geometry.type === 'Polygon' || geometry.type === 'MultiLineString') {

const coordinates = geometry.coordinates;

const newGeometry = {

type: geometry.type,

coordinates: coordinates.map((items) => {

return items.map((item) => {

return transformCoordinate(fromProjection, toProjection, item);

});

})

};

return newGeometry;

}

if (geometry.type === 'MultiPoint' || geometry.type === 'LineString') {

const coordinates = geometry.coordinates;

const newGeometry = {

type: geometry.type,

coordinates: coordinates.map((item) => {

return transformCoordinate(fromProjection, toProjection, item);

})

};

return newGeometry;

}

if (geometry.type === 'Point') {

const newGeometry = {

type: geometry.type,

coordinates: transformCoordinate(fromProjection, toProjection, geometry.coordinates)

};

return newGeometry;

}

}

/**

function transformGeometryCoordinates(features, fromProjection, toProjection = 'EPSG:4326') {

if (!features || !features.length || !fromProjection) {

return;

}

if (fromProjection === toProjection) {

return features;

}

return features.map((f) => {

const geometry = transformGeometryCoordinatesUtil(fromProjection, toProjection, f.geometry);

const newFeature = { ...f };

geometry && Object.assign(newFeature, { geometry });

return newFeature;

});

}

/**

async function getStructuredDataGeojsonByWebMap(data, options) {

const allFeature = await getStructDataGeojson(data.dataId, options);

const resultRes = await FetchRequest.get(

`${options.server}web/datas/${data.dataId}/structureddata.json`,

null,

options

);

const result = await resultRes.json();

const projection = `EPSG:${result.epsgCode}`;

if (projection !== 'EPSG:4326') {

if (!getProjection(projection, proj4)) {

const epsgWKT = await getEpsgCodeInfo(projection, options.server);

registerProjection(projection, epsgWKT, proj4);

}

const newFeatures = transformGeometryCoordinates(allFeature.features, projection);

newFeatures && (allFeature.features = newFeatures);

}

return allFeature;

}

function webmapODToParser(data) {

const { originX, originY, destinationX, destinationY } = data;

return {

type: 'json',

x: originX,

y: originY,

x1: destinationX,

y1: destinationY

};

}

function webmapClusterToTransform(data) {

const { clusterField, clusterMethod, clusterRadius, clusterType } = data;

const methodRules = {

avg: 'mean'

};

return [

{

type: clusterType,

field: clusterField,

method: (clusterMethod && methodRules[clusterMethod]) || clusterMethod,

size: clusterRadius

}

];

}

/**

async function geoJSONSourceToL7Source(source, sourceLayer, options) {

const { data, od, cluster } = source;

if (data && data.type === 'FeatureCollection') {

return {

data

};

}

const rules = {

'supermap-rest-data': getRestDataGeojsonByWebMap,

'supermap-structured-data': getStructuredDataGeojsonByWebMap

};

const parser = od && webmapODToParser(source);

const transforms = cluster && webmapClusterToTransform(source);

return {

data: rules[data.type] && (await rules[data.type](source.data, options)),

parser,

transforms

};

}

/**

function vectorSourceToL7Source(source, sourceLayer, options) {

const result = {

data: ((source || {}).tiles || [])[0],

parser: {

type: 'mvt',

extent: source.bounds,

sourceLayer

}

};

const requestParameters = options.transformRequest(result.data, 'Tile');

if (requestParameters) {

if (requestParameters.credentials) {

result.parser.requestParameters = { credentials: requestParameters.credentials };

}

if (requestParameters.headers) {

result.parser.requestParameters = { ...result.parser.requestParameters, headers: requestParameters.headers };

}

}

return result;

}

/**

function WebMapSourceToL7Source(source, sourceLayer, options) {

const type = source.type;

const rules = {

vector: vectorSourceToL7Source,

geojson: geoJSONSourceToL7Source

};

return rules[type] && rules[type](source, sourceLayer, options);

}

/**

function getL7LayerCommonInfo(layer) {

const { type, id, minzoom, maxzoom, layout, paint, filter, source } = layer;

return {

id,

options: {

type,

name: layer.id,

sourceLayer: layer['source-layer'],

source,

layout,

paint,

filter,

minZoom: minzoom,

maxZoom: maxzoom,

visible: layout.visibility === 'none' ? false : true

},

filter: getL7Filter(filter, featureFilter)

};

}

function expressionToFunction({ value, property, multiple, map }) {

if (!expression.isExpression(value)) {

return {

values: multiple ? value * multiple : value

};

}

const typeRules = {

size: 'paint_circle',

color: 'paint_circle',

shape: 'layout_symbol'

};

const rules = {

size: 'circle-radius',

color: 'circle-color',

shape: 'icon-image'

};

const fieldRules = {

interpolate: (compiledExpression) => {

return compiledExpression.value._styleExpression.expression.input.args[0].args[0].evaluate(

compiledExpression.value._styleExpression._evaluator

);

},

match: (compiledExpression) => {

return compiledExpression.value._styleExpression.expression.input.args[0].evaluate(

compiledExpression.value._styleExpression._evaluator

);

},

case: (compiledExpression) => {

const branches = compiledExpression.value._styleExpression.expression.branches[0][0];

// args[0]适用于分段，arg.lhs适用于单值转换成case表达式

if (branches && branches.args) {

return branches.args[0].lhs.args[0].args[0].evaluate(compiledExpression.value._styleExpression._evaluator);

}

return branches.lhs.args[0].evaluate();

}

};

const propertySpec = spec[typeRules[property]][rules[property]];

const compiledExpression = expression.createPropertyExpression(value, propertySpec);

const field = fieldRules[value[0]] && fieldRules[value[0]](compiledExpression);

const newFunc = compiledExpression.value.evaluate.bind(compiledExpression.value);

const callback = (v) => {

const f = {

properties: { [field]: v },

type: 'point'

};

const result = newFunc({ zoom: map.getZoom() }, f);

return property === 'shape' ? result.toString() : multiple ? result * multiple : result;

};

return {

field,

values: callback

};

}

function getLineCurveStyleKey(type, key) {

const ANTVL7_LINE_CURVE_STYLE_KEY = {

[`${type}-dasharray`]: 'dashArray',

[`${type}-opacity`]: 'opacity',

[`${type}-pattern-color`]: 'textureColor',

[`${type}-pattern-opacity`]: 'opacity',

[`${type}-pattern-interval`]: 'iconStep',

[`${type}-pattern-blend`]: 'textureBlend',

[`${type}-segment`]: 'segmentNumber',

[`${type}-pattern-rotate`]: 'textureRotate'

};

return ANTVL7_LINE_CURVE_STYLE_KEY[key];

}

function getLineCurveAnimateKey(type, key) {

const ANTVL7_ANIMATE_LINE_CURVE_STYLE_KEY = {

[`${type}-animate-duration`]: 'duration',

[`${type}-animate-interval`]: 'interval',

[`${type}-animate-trailLength`]: 'trailLength'

};

return ANTVL7_ANIMATE_LINE_CURVE_STYLE_KEY[key];

}

/**

function getCompositeField(...args) {

return args

.filter((a) => a.field)

.map((a) => {

return a.field;

})

.join('*');

}

/**

function getCompositeCallback(valueArgs, args) {

const newValueArgs = [...valueArgs];

return args.map((attr) => {

const multiple = attr.multiple;

if (attr.field) {

const value = newValueArgs[0];

newValueArgs.unshift();

const result = attr && attr.values ? attr.values(value) : value;

return multiple && isNumber(result) ? result * multiple : result;

}

return multiple && isNumber(attr.values) ? attr.values * multiple : attr.values;

});

}

/**

function expressionMultiToFunction(map, ...size) {

const functions = size.map(({ value, multiple }) => expressionToFunction({ value, property: 'size', multiple, map }));