'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var shared = require('@vue/shared');
var isUndefined = require('lodash/isUndefined');
var isNull = require('lodash/isNull');
var camelCase = require('lodash/camelCase');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var isUndefined__default = /*#__PURE__*/_interopDefaultLegacy(isUndefined);
var isNull__default = /*#__PURE__*/_interopDefaultLegacy(isNull);
var camelCase__default = /*#__PURE__*/_interopDefaultLegacy(camelCase);

function useGlobalConfig() {
    const vm = vue.getCurrentInstance();
    if ('$VueCesium' in vm.proxy) {
        return vm.proxy.$VueCesium;
    }
    return {};
}
function getFileNameByPath(path) {
    const posStart = path.lastIndexOf('/');
    const posEnd = path.lastIndexOf('.');
    return path.substring(posStart + 1, posEnd);
}
function dirname(path) {
    if (typeof path !== 'string')
        path = path + '';
    if (path.length === 0)
        return '.';
    let code = path.charCodeAt(0);
    const hasRoot = code === 47;
    let end = -1;
    let matchedSlash = true;
    for (let i = path.length - 1; i >= 1; --i) {
        code = path.charCodeAt(i);
        if (code === 47) {
            if (!matchedSlash) {
                end = i;
                break;
            }
        }
        else {
            matchedSlash = false;
        }
    }
    if (end === -1)
        return hasRoot ? '/' : '.';
    if (hasRoot && end === 1) {
        return '/';
    }
    return path.slice(0, end);
}
function removeEmpty(obj) {
    const finalObj = {};
    Object.keys(obj).forEach(key => {
        const className = getObjClassName(obj[key]);
        if ((obj[key] && shared.isArray(obj[key]) || obj[key] instanceof Element)) {
            finalObj[key] = obj[key];
        }
        else if (obj[key] && typeof obj[key] === 'object' && !Cesium[className]) {
            const nestedObj = removeEmpty(obj[key]);
            if (Object.keys(nestedObj).length) {
                finalObj[key] = nestedObj;
            }
        }
        else if (obj[key] !== '' && obj[key] !== undefined && obj[key] !== null) {
            finalObj[key] = obj[key];
        }
    });
    return finalObj;
}
function isEmptyObj(obj) {
    if (isUndefined__default['default'](obj) || isNull__default['default'](obj)) {
        return true;
    }
    if (obj instanceof Element) {
        return false;
    }
    const arr = Object.keys(obj);
    return arr.length === 0;
}
const kebabCase = shared.hyphenate;
function getObjClassName(obj) {
    if (obj && obj.constructor) {
        const strFun = obj.constructor.toString();
        let className = strFun.substr(0, strFun.indexOf('('));
        className = className.replace('function', '');
        return className.replace(/(^\s*)|(\s*$)/gi, '');
    }
    return typeof obj;
}
function lnglatValidator(longitude, latitude) {
    const longreg = /^(-|\+)?(((\d|[1-9]\d|1[0-7]\d|0{1,3})\.\d{0,15})|(\d|[1-9]\d|1[0-7]\d|0{1,3})|180\.0{0,15}|180)$/;
    if (!longreg.test(longitude.toString())) {
        return false;
    }
    const latreg = /^(-|\+)?([0-8]?\d{1}\.\d{0,15}|90\.0{0,15}|[0-8]?\d{1}|90)$/;
    if (!latreg.test(latitude.toString())) {
        return false;
    }
    return true;
}
function defaultValue(a, b) {
    if (a !== undefined && a !== null) {
        return a;
    }
    return b;
}
function inherit(base, derived) {
    function F() {
    }
    F.prototype = base.prototype;
    derived.prototype = new F();
    derived.prototype.constructor = derived;
}
const getDefaultOptionByProps = (props, ignores = []) => {
    const defaultOptions = {};
    Object.keys(props).forEach(key => {
        if (ignores.indexOf(key) === -1) {
            const value = props[key];
            defaultOptions[key] = shared.isFunction(value)
                ? undefined
                : shared.isPlainObject(value)
                    ? shared.isFunction(value.default)
                        ? value.default()
                        : value.default
                    : value;
        }
    });
    return defaultOptions;
};

Object.defineProperty(exports, 'camelize', {
  enumerable: true,
  get: function () {
    return shared.camelize;
  }
});
Object.defineProperty(exports, 'capitalize', {
  enumerable: true,
  get: function () {
    return shared.capitalize;
  }
});
Object.defineProperty(exports, 'extend', {
  enumerable: true,
  get: function () {
    return shared.extend;
  }
});
Object.defineProperty(exports, 'hasOwn', {
  enumerable: true,
  get: function () {
    return shared.hasOwn;
  }
});
Object.defineProperty(exports, 'isArray', {
  enumerable: true,
  get: function () {
    return shared.isArray;
  }
});
Object.defineProperty(exports, 'isFunction', {
  enumerable: true,
  get: function () {
    return shared.isFunction;
  }
});
Object.defineProperty(exports, 'isObject', {
  enumerable: true,
  get: function () {
    return shared.isObject;
  }
});
Object.defineProperty(exports, 'isPlainObject', {
  enumerable: true,
  get: function () {
    return shared.isPlainObject;
  }
});
Object.defineProperty(exports, 'isString', {
  enumerable: true,
  get: function () {
    return shared.isString;
  }
});
Object.defineProperty(exports, 'looseEqual', {
  enumerable: true,
  get: function () {
    return shared.looseEqual;
  }
});
Object.defineProperty(exports, 'isUndefined', {
  enumerable: true,
  get: function () {
    return isUndefined__default['default'];
  }
});
Object.defineProperty(exports, 'camelCase', {
  enumerable: true,
  get: function () {
    return camelCase__default['default'];
  }
});
exports.defaultValue = defaultValue;
exports.dirname = dirname;
exports.getDefaultOptionByProps = getDefaultOptionByProps;
exports.getFileNameByPath = getFileNameByPath;
exports.getObjClassName = getObjClassName;
exports.inherit = inherit;
exports.isEmptyObj = isEmptyObj;
exports.kebabCase = kebabCase;
exports.lnglatValidator = lnglatValidator;
exports.removeEmpty = removeEmpty;
exports.useGlobalConfig = useGlobalConfig;
