@rnmapbox/maps 10.0.0-beta.28

package/rnmapbox-maps.podspec

@@ -0,0 +1,264 @@
+# Customization:
+#  $RNMapboxMapsImpl - one of (maplibre, mapbox, mapbox-gl)
+#  $RNMapboxMapsVersion - version specification ("~> 10.4.3", "~> 5.9.0" or "exactVersion 5.12.1" mapblibre/SPM)
+#  $RNMapboxMapsSwiftPackageManager can be either
+#     "manual" - you're responsible for the Mapbox lib dependency either using cocoapods or SPM
+#     Hash - ```
+#         {
+#           url: "https://github.com/maplibre/maplibre-gl-native-distribution",
+#           requirement: {
+#             kind: 'exactVersion',
+#             version: 5.12.1,
+#           },
+#           product_name: "Mapbox"
+#         }
+#         ```
+#  $RNMapboxMapsDownloadToken - *expo only* download token
+
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+## Warning: these lines are scanned by autogenerate.js
+rnMapboxMapsDefaultMapboxVersion = '~> 10.7.0'
+rnMapboxMapsDefaultMapboxGLVersion = '~> 5.9.0'
+rnMapboxMapsDefaultMapLibreVersion = 'exactVersion 5.12.1'
+
+rnMapboxMapsDefaultImpl = 'maplibre'
+
+# DEPRECATIONS
+
+if ENV["REACT_NATIVE_MAPBOX_GL_USE_FRAMEWORKS"]
+  puts "REACT_NATIVE_MAPBOX_GL_USE_FRAMEWORKS is now deprecated!"
+end
+
+if $RNMBGL_Use_SPM
+  puts "WARNING: $RNMBGL_Use_SPM is deprecated - use $RNMapboxMapsSwiftPackageManager"
+  if $RNMBGL_Use_SPM.is_a?(Hash)
+    $RNMapboxMapsSwiftPackageManager = $RNMBGL_Use_SPM
+  else
+    $RNMapboxMapsImpl = 'maplibre' unless $RNMapboxMapsImpl
+    $RNMapboxMapsSwiftPackageManager = {
+      url: "https://github.com/maplibre/maplibre-gl-native-distribution",
+      requirement: {
+        kind: rnMapboxMapsDefaultMapLibreVersion.split.first,
+        version: rnMapboxMapsDefaultMapLibreVersion.split.last,
+      },
+      product_name: "Mapbox"
+    }
+  end
+end
+
+if $RNMBGL_USE_V10
+  puts "WARNING: $RNMBGL_USE_V10 is deprecated - use $RNMapboxMapsImpl = 'mapbox'"
+  $RNMapboxMapsImpl = 'mapbox'
+end
+
+if $RNMBGL_USE_MAPLIBRE
+  puts "WARNING: $RNMBGL_USE_MAPLIBRE is deprecated - use $RNMapboxMapsImpl = 'maplibre'"
+  $RNMapboxMapsImpl = 'maplibre'
+end
+
+if ENV.has_key?("REACT_NATIVE_MAPBOX_MAPBOX_IOS_VERSION")
+  puts "WARNING: REACT_NATIVE_MAPBOX_MAPBOX_IOS_VERSION env is deprecated please use `$RNMapboxMapsVersion = \"#{ENV['REACT_NATIVE_MAPBOX_MAPBOX_IOS_VERSION']}\"`"
+  $RNMapboxMapsVersion = ENV["REACT_NATIVE_MAPBOX_MAPBOX_IOS_VERSION"]
+end
+
+if $ReactNativeMapboxGLIOSVersion
+  puts "WARNING: $ReactNativeMapboxGLIOSVersion is deprecated use `$RNMapboxMapsVersion = \"#{$ReactNativeMapboxGLIOSVersion}\"`"
+  $RNMapboxMapsVersion = $ReactNativeMapboxGLIOSVersion
+end
+
+$RNMBGL = Object.new
+
+def $RNMBGL.pre_install(installer)
+  puts "WARNING: $RNMBGL.pre_install is deprecated - use $RNMapboxMaps.pre_install"
+  $RNMapboxMaps.pre_install(installer)
+end
+
+def $RNMBGL.post_install(installer)
+  puts "WARNING: $RNMBGL.post_install is deprecated - use $RNMapboxMaps.post_install"
+  $RNMapboxMaps.post_install(installer)
+end
+
+# --
+
+$RNMapboxMapsImpl = rnMapboxMapsDefaultImpl unless $RNMapboxMapsImpl
+
+case $RNMapboxMapsImpl
+when 'mapbox'
+  rnMapboxMapsTargetsToChangeToDynamic = ['MapboxMobileEvents', 'Turf', 'MapboxMaps', 'MapboxCoreMaps', 'MapboxCommon']
+  MapboxImplVersion = $RNMapboxMapsVersion || rnMapboxMapsDefaultMapboxVersion
+when 'mapbox-gl'
+  rnMapboxMapsTargetsToChangeToDynamic = ['MapboxMobileEvents']
+  MapboxImplVersion = $RNMapboxMapsVersion || rnMapboxMapsDefaultMapboxGLVersion
+when 'maplibre'
+  rnMapboxMapsTargetsToChangeToDynamic = ['MapboxMobileEvents']
+
+  spm_version = ($RNMapboxMapsVersion || rnMapboxMapsDefaultMapLibreVersion).split
+  if spm_version.length < 2
+    spm_version.prepend('exactVersion')
+  end
+
+  unless $RNMapboxMapsSwiftPackageManager
+    $RNMapboxMapsSwiftPackageManager = {
+      url: "https://github.com/maplibre/maplibre-gl-native-distribution",
+      requirement: {
+        kind: spm_version[0],
+        version: spm_version[1],
+      },
+      product_name: "Mapbox"
+    }
+  end
+else
+  fail "$RNMapboxMapsImpl should be one of mapbox, mapbox-gl, maplibre"
+end
+
+$RNMapboxMaps = Object.new
+
+def $RNMapboxMaps._check_no_mapbox_spm(project)
+  pkg_class = Xcodeproj::Project::Object::XCRemoteSwiftPackageReference
+  ref_class = Xcodeproj::Project::Object::XCSwiftPackageProductDependency
+  pkg = project.root_object.package_references.find { |p| p.class == pkg_class && [
+    "https://github.com/maplibre/maplibre-gl-native-distribution",
+    "https://github.com/mapbox/mapbox-maps-ios.git"
+  ].include?(p.repositoryURL) }
+  if pkg
+    puts "!!! Warning: Duplicate Mapbox dependency found, it's consumed by both SwiftPackageManager and CocoaPods"
+  end
+end
+
+def $RNMapboxMaps._add_spm_to_target(project, target, url, requirement, product_name)
+  pkg_class = Xcodeproj::Project::Object::XCRemoteSwiftPackageReference
+  ref_class = Xcodeproj::Project::Object::XCSwiftPackageProductDependency
+  pkg = project.root_object.package_references.find { |p| p.class == pkg_class && p.repositoryURL == url }
+  if !pkg
+    pkg = project.new(pkg_class)
+    pkg.repositoryURL = url
+    pkg.requirement = requirement
+    project.root_object.package_references << pkg
+  end
+  ref = target.package_product_dependencies.find { |r| r.class == ref_class && r.package == pkg && r.product_name == product_name }
+  if !ref
+    ref = project.new(ref_class)
+    ref.package = pkg
+    ref.product_name = product_name
+    target.package_product_dependencies << ref
+  end
+end
+
+def $RNMapboxMaps.post_install(installer)
+  if $RNMapboxMapsSwiftPackageManager
+    return if $RNMapboxMapsSwiftPackageManager == "manual"
+
+    spm_spec = $RNMapboxMapsSwiftPackageManager
+    project = installer.pods_project
+    self._add_spm_to_target(
+      project,
+      project.targets.find { |t| t.name == "rnmapbox-maps"},
+      spm_spec[:url],
+      spm_spec[:requirement],
+      spm_spec[:product_name]
+    )
+
+    installer.aggregate_targets.group_by(&:user_project).each do |project, targets|
+      targets.each do |target|
+        target.user_targets.each do |user_target|
+          self._add_spm_to_target(
+            project,
+            user_target,
+            spm_spec[:url],
+            spm_spec[:requirement],
+            spm_spec[:product_name]
+          )
+        end
+      end
+    end
+  else
+    self._check_no_mapbox_spm(installer.pods_project)
+    installer.aggregate_targets.group_by(&:user_project).each do |project, targets|
+      targets.each do |target|
+        target.user_targets.each do |user_target|
+          self._check_no_mapbox_spm(project)
+        end
+      end
+    end
+  end
+end
+
+$rnMapboxMapsTargetsToChangeToDynamic = rnMapboxMapsTargetsToChangeToDynamic
+
+def $RNMapboxMaps.pre_install(installer)
+  installer.aggregate_targets.each do |target|
+    target.pod_targets.select { |p| $rnMapboxMapsTargetsToChangeToDynamic.include?(p.name) }.each do |mobile_events_target|
+      mobile_events_target.instance_variable_set(:@build_type,Pod::BuildType.dynamic_framework)
+      puts "* [RNMapbox] Changed #{mobile_events_target.name} to #{mobile_events_target.send(:build_type)}"
+      fail "* [RNMapbox] Unable to change build_type" unless mobile_events_target.send(:build_type) == Pod::BuildType.dynamic_framework
+    end
+  end
+end
+
+## RNMapboxMapsDownloadToken
+# expo does not supports `.netrc`, so we need to patch curl commend used by cocoapods to pass the credentials
+
+if $RNMapboxMapsDownloadToken
+  module AddCredentialsToCurlWhenDownloadingMapbox
+    def curl!(*args)
+      mapbox_download = args.flatten.any? { |i| i.to_s.start_with?('https://api.mapbox.com') }
+      if mapbox_download
+        arguments = args.flatten
+        arguments.prepend("-u","mapbox:#{$RNMapboxMapsDownloadToken}")
+        super(*arguments)
+      else
+        super
+      end
+    end
+  end
+
+  class Pod::Downloader::Http
+    prepend AddCredentialsToCurlWhenDownloadingMapbox
+  end
+end
+
+Pod::Spec.new do |s|
+  s.name		= "rnmapbox-maps"
+  s.summary		= "React Native Component for Mapbox"
+  s.version		= package['version']
+  s.authors		= { "Miklós Fazekas" => "mfazekas@szemafor.com (https://github.com/mfazekas/)" }
+  s.homepage    	= "https://github.com/rnmapbox/maps#readme"
+  s.source      	= { :git => "https://github.com/rnmapbox/maps.git" }
+  s.license     	= "MIT"
+  s.platform    	= :ios, "11.0"
+
+  unless $RNMapboxMapsSwiftPackageManager
+    case $RNMapboxMapsImpl
+    when 'mapbox'
+      s.dependency 'MapboxMaps', MapboxImplVersion
+      s.dependency 'Turf'
+      s.swift_version = '5.0'
+    when 'mapbox-gl'
+      s.dependency 'Mapbox-iOS-SDK', MapboxImplVersion
+    when 'maplibre'
+      fail "internal error: maplibre requires $RNMapboxMapsSwiftPackageManager"
+    else
+      fail "$RNMapboxMapsImpl should be one of mapbox, mapbox-gl, maplibre"
+    end
+  end
+
+  s.dependency 'React-Core'
+  s.dependency 'React'
+
+  s.subspec 'DynamicLibrary' do |sp|
+    case $RNMapboxMapsImpl
+    when 'mapbox'
+      sp.source_files = "ios/RCTMGL-v10/**/*.{h,m,swift}"
+    when 'mapbox-gl'
+      sp.source_files	= "ios/RCTMGL/**/*.{h,m}"
+    when 'maplibre'
+      sp.source_files	= "ios/RCTMGL/**/*.{h,m}"
+      sp.compiler_flags = '-DRNMBGL_USE_MAPLIBRE=1'
+    end
+  end
+
+  s.default_subspecs= ['DynamicLibrary']
+end

package/scripts/.eslintrc.js

@@ -0,0 +1,12 @@
+module.exports = {
+  globals: {
+    camelCase: true,
+    pascelCase: true,
+    startAtSpace: true,
+    replaceNewLine: true,
+    exists: true,
+    androidInputType: true,
+    androidOutputType: true,
+    iosPropName: true,
+  },
+};

package/scripts/autogenHelpers/DocJSONBuilder.js

@@ -0,0 +1,345 @@
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+
+const dir = require('node-dir');
+const docgen = require('react-docgen');
+const parseJsDoc = require('react-docgen/dist/utils/parseJsDoc').default;
+
+const JSDocNodeTree = require('./JSDocNodeTree');
+
+const COMPONENT_PATH = path.join(
+  __dirname,
+  '..',
+  '..',
+  'javascript',
+  'components',
+);
+const MODULES_PATH = path.join(__dirname, '..', '..', 'javascript', 'modules');
+
+const OUTPUT_PATH = path.join(__dirname, '..', '..', 'docs', 'docs.json');
+const IGNORE_FILES = [
+  'AbstractLayer',
+  'AbstractSource',
+  'NativeBridgeComponent',
+];
+
+const IGNORE_METHODS = ['setNativeProps'];
+
+const fileExtensionsRegex = /.(js|tsx|(?<!d.)ts)$/;
+
+class DocJSONBuilder {
+  constructor(styledLayers) {
+    this._styledLayers = {};
+
+    for (const styleLayer of styledLayers) {
+      let ComponentName = pascelCase(styleLayer.name);
+      const fakeLayers = ['Light', 'Atmosphere', 'Terrain'];
+      if (fakeLayers.includes(ComponentName)) {
+        this._styledLayers[ComponentName] = styleLayer;
+      } else {
+        this._styledLayers[ComponentName + 'Layer'] = styleLayer;
+      }
+    }
+  }
+
+  get options() {
+    return {
+      match: fileExtensionsRegex,
+      shortName: true,
+    };
+  }
+
+  isPrivateMethod(methodName = '') {
+    return !methodName || methodName.charAt(0) === '_';
+  }
+
+  postprocess(component, name) {
+    // Remove all private methods and parse examples from docblock
+
+    if (!Array.isArray(component.methods)) {
+      return;
+    }
+
+    component.name = name;
+
+    // Main description
+    component.description = component.description.replace(
+      /(\n*)(@\w+) (\{.*\})/g,
+      '',
+    );
+
+    // Styles
+    if (this._styledLayers[name] && this._styledLayers[name].properties) {
+      component.styles = [];
+
+      for (const prop of this._styledLayers[name].properties) {
+        const docStyle = {
+          name: prop.name,
+          type: prop.type,
+          values: [],
+          minimum: prop.doc.minimum,
+          maximum: prop.doc.maximum,
+          units: prop.doc.units,
+          default: prop.doc.default,
+          description: prop.doc.description,
+          requires: prop.doc.requires,
+          disabledBy: prop.doc.disabledBy,
+          allowedFunctionTypes: prop.allowedFunctionTypes || [],
+          expression: prop.expression,
+          transition: prop.transition,
+        };
+        if (prop.type === 'enum') {
+          docStyle.values = Object.keys(prop.doc.values).map((value) => {
+            return { value, doc: prop.doc.values[value].doc };
+          });
+        } else if (prop.type === 'array') {
+          docStyle.type = `${docStyle.type}<${prop.value}>`;
+        }
+
+        component.styles.push(docStyle);
+      }
+    }
+
+    function mapNestedProp(propMeta) {
+      const result = {
+        type: {
+          name: propMeta.name,
+          value: propMeta.value,
+        },
+        description: propMeta.description,
+        required: propMeta.required,
+      };
+      if (propMeta.value) {
+        result.type.value = propMeta.value;
+      }
+      return result;
+    }
+
+    function tsTypeDesc(tsType) {
+      if (!tsType?.name) {
+        return null;
+      }
+
+      if (tsType.name === 'signature') {
+        if (tsType.raw.length < 200) {
+          return `${tsType.raw
+            .replace(/(\n|\s)/g, '')
+            .replace(/(\|)/g, '\\|')}`;
+        } else {
+          return 'FIX ME FORMAT BIG OBJECT';
+        }
+      } else if (tsType.name === 'union') {
+        if (tsType.raw) {
+          // Props
+          return tsType.raw.replace(/\|/g, '\\|');
+        } else if (tsType.elements) {
+          // Methods
+          return tsType.elements.map((e) => e.name).join(' \\| ');
+        }
+      } else {
+        return tsType.name;
+      }
+    }
+
+    function mapProp(propMeta, propName, array) {
+      let result = {};
+      if (!array) {
+        result = {
+          name: propName || 'FIX ME NO NAME',
+          required: propMeta.required || false,
+          type:
+            propMeta.type?.name ||
+            tsTypeDesc(propMeta.tsType) ||
+            'FIX ME UNKNOWN TYPE',
+          default: !propMeta.defaultValue
+            ? 'none'
+            : propMeta.defaultValue.value.replace(/\n/g, ''),
+          description: propMeta.description || 'FIX ME NO DESCRIPTION',
+        };
+      } else {
+        if (propName) {
+          result.name = propName;
+        }
+        if (propMeta.required !== undefined) {
+          result.required = propMeta.required;
+        }
+        result.type =
+          (propMeta.type && propMeta.type.name) ||
+          tsTypeDesc(propMeta.tsType) ||
+          'FIX ME UNKNOWN TYPE';
+        if (propMeta.defaultValue) {
+          result.default = propMeta.defaultValue.value.replace(/\n/g, '');
+        }
+        if (propMeta.description) {
+          result.description = propMeta.description;
+        }
+      }
+
+      if (
+        propMeta.type &&
+        propMeta.type.name === 'arrayOf' &&
+        propMeta.type.value
+      ) {
+        result.type = {
+          name: 'array',
+          value: mapProp(mapNestedProp(propMeta.type.value), undefined, true),
+        };
+      }
+
+      if (propMeta.type && propMeta.type.name === 'func') {
+        const jsdoc = parseJsDoc(propMeta.description);
+        if (jsdoc && jsdoc.description) {
+          result.description = jsdoc.description;
+        }
+        if (jsdoc && jsdoc.params && jsdoc.params.length > 0) {
+          result.params = jsdoc.params;
+        }
+        if (jsdoc && jsdoc.returns) {
+          result.returns = jsdoc.returns;
+        }
+      }
+      if (
+        propMeta.type &&
+        propMeta.type.name === 'shape' &&
+        propMeta.type.value
+      ) {
+        const type = propMeta.type.value;
+        const value = Object.keys(type).map((_name) =>
+          mapProp(mapNestedProp(type[_name]), _name, false),
+        );
+        result.type = { name: 'shape', value };
+      }
+      return result;
+    }
+
+    // props
+    component.props = Object.keys(component.props).map((propName) => {
+      const propMeta = component.props[propName];
+
+      return mapProp(propMeta, propName, false);
+    });
+
+    // methods
+    const privateMethods = [];
+    for (const method of component.methods) {
+      if (this.isPrivateMethod(method.name)) {
+        privateMethods.push(method.name);
+        continue;
+      }
+
+      if (method.docblock) {
+        const examples = method.docblock
+          .split('@')
+          .filter((block) => block.startsWith('example'));
+        method.examples = examples.map((example) =>
+          example.substring('example'.length),
+        );
+      }
+    }
+    privateMethods.push(...IGNORE_METHODS);
+
+    component.methods = component.methods.filter(
+      (method) => !privateMethods.includes(method.name),
+    );
+
+    component.methods.forEach((method) => {
+      method.params.forEach((param) => {
+        param.type = { name: tsTypeDesc(param.type) };
+      });
+    });
+
+    console.log(
+      `Processed ${component.name} (${component.props?.length ?? 0} props, ${
+        component.methods?.length ?? 0
+      } methods)`,
+    );
+  }
+
+  generateReactComponentsTask(results, filePath) {
+    return new Promise((resolve, reject) => {
+      dir.readFiles(
+        filePath,
+        this.options,
+        (err, content, fileNameWithExt, next) => {
+          if (err) {
+            return reject(err);
+          }
+
+          let fileName = fileNameWithExt.replace(/.(js)/, '');
+
+          if (IGNORE_FILES.includes(fileName)) {
+            next();
+            return;
+          }
+
+          let parsed = docgen.parse(content, undefined, undefined, {
+            filename: fileName,
+          });
+          fileName = fileName.replace(fileExtensionsRegex, '');
+          parsed.fileNameWithExt = fileNameWithExt;
+          results[fileName] = parsed;
+
+          this.postprocess(results[fileName], fileName);
+
+          next();
+        },
+        () => resolve(),
+      );
+    });
+  }
+
+  generateModulesTask(results, filePath) {
+    return new Promise((resolve, reject) => {
+      exec(
+        `npx documentation build ${MODULES_PATH} -f json`,
+        (err, stdout, stderr) => {
+          if (err || stderr) {
+            reject(err || stderr);
+            return;
+          }
+
+          const modules = JSON.parse(stdout);
+          for (const module of modules) {
+            const node = new JSDocNodeTree(module);
+            const name = `${module.name
+              .charAt(0)
+              .toLowerCase()}${module.name.substring(1)}`;
+
+            const pathParts = module.context.file.split('/');
+            const fileNameWithExt = pathParts[pathParts.length - 1];
+
+            results[name] = {
+              name,
+              fileNameWithExt,
+              description: node.getText(),
+              props: [],
+              styles: [],
+              methods: node.getMethods(),
+            };
+          }
+
+          resolve();
+        },
+      );
+    });
+  }
+
+  async generate() {
+    this.generateModulesTask({}, MODULES_PATH);
+
+    const results = {};
+
+    const tasks = [
+      this.generateReactComponentsTask(results, COMPONENT_PATH),
+      this.generateModulesTask(results, MODULES_PATH),
+    ];
+
+    return Promise.all(tasks).then(() => {
+      fs.writeFileSync(OUTPUT_PATH, JSON.stringify(results, null, 2));
+      return true;
+    });
+  }
+}
+
+module.exports = DocJSONBuilder;