@maplibre/maplibre-react-native 10.0.0-alpha.21 → 10.0.0-alpha.22

package/scripts/autogenHelpers/globals.js

@@ -1,508 +0,0 @@
-let iosPropNameOverrides = {};
-
-const iosSpecOverrides = {
-  'icon-allow-overlap': 'icon-allows-overlap',
-  'icon-image': 'icon-image-name',
-  'icon-ignore-placement': 'icon-ignores-placement',
-  'icon-keep-upright': 'keeps-icon-upright',
-  'icon-rotate': 'icon-rotation',
-  'icon-size': 'icon-scale',
-  'symbol-avoid-edges': 'symbol-avoids-edges',
-  'text-allow-overlap': 'text-allows-overlap',
-  'text-field': 'text',
-  'text-font': 'text-font-names',
-  'text-ignore-placement': 'text-ignores-placement',
-  'text-justify': 'text-justification',
-  'text-keep-upright': 'keeps-text-upright',
-  'text-max-angle': 'maximum-text-angle',
-  'text-max-width': 'maximum-text-width',
-  'text-rotate': 'text-rotation',
-  'text-size': 'text-font-size',
-  'circle-pitch-scale': 'circle-scale-alignment',
-  'circle-translate': 'circle-translation',
-  'circle-translate-anchor': 'circle-translation-anchor',
-  'fill-antialias': 'fill-antialiased',
-  'fill-translate': 'fill-translation',
-  'fill-translate-anchor': 'fill-translation-anchor',
-  'fill-extrusion-translate': 'fill-extrusion-translation',
-  'fill-extrusion-translate-anchor': 'fill-extrusion-translation-anchor',
-  'raster-brightness-min': 'minimum-raster-brightness',
-  'raster-brightness-max': 'maximum-raster-brightness',
-  'raster-hue-rotate': 'raster-hue-rotation',
-  'line-dasharray': 'line-dash-pattern',
-  'line-translate': 'line-translation',
-  'line-translate-anchor': 'line-translation-anchor',
-  'icon-translate': 'icon-translation',
-  'icon-translate-anchor': 'icon-translation-anchor',
-  'text-translate': 'text-translation',
-  'text-translate-anchor': 'text-translation-anchor',
-  'raster-resampling': 'raster-resampling-mode',
-  'text-writing-mode': 'text-writing-modes',
-};
-
-global.getValue = function (value, defaultValue) {
-  if (!exists(value) || value === '') {
-    return defaultValue;
-  }
-  return value;
-};
-
-global.exists = function (value) {
-  return typeof value !== 'undefined' && value !== null;
-};
-
-global.camelCase = function (str, delimiter = '-') {
-  const parts = str.split(delimiter);
-  return parts
-    .map((part, index) => {
-      if (index === 0) {
-        return part;
-      }
-      return part.charAt(0).toUpperCase() + part.substring(1);
-    })
-    .join('');
-};
-
-global.pascelCase = function (str, delimiter = '-') {
-  const parts = str.split(delimiter);
-  return parts
-    .map((part, index) => {
-      return part.charAt(0).toUpperCase() + part.substring(1);
-    })
-    .join('');
-};
-
-global.setLayerMethodName = function (layer, platform) {
-  if (platform === 'ios') {
-    return `${camelCase(layer.name)}Layer`;
-  }
-  return `set${pascelCase(layer.name)}LayerStyle`;
-};
-
-global.getLayerType = function (layer, platform) {
-  const isIOS = platform === 'ios';
-
-  switch (layer.name) {
-    case 'fill':
-      return isIOS ? 'MLNFillStyleLayer' : 'FillLayer';
-    case 'fill-extrusion':
-      return isIOS ? 'MLNFillExtrusionStyleLayer' : 'FillExtrusionLayer';
-    case 'line':
-      return isIOS ? 'MLNLineStyleLayer' : 'LineLayer';
-    case 'symbol':
-      return isIOS ? 'MLNSymbolStyleLayer' : 'SymbolLayer';
-    case 'circle':
-      return isIOS ? 'MLNCircleStyleLayer' : 'CircleLayer';
-    case 'background':
-      return isIOS ? 'MLNBackgroundStyleLayer' : 'BackgroundLayer';
-    case 'raster':
-      return isIOS ? 'MLNRasterStyleLayer' : 'RasterLayer';
-    case 'heatmap':
-      return isIOS ? 'MLNHeatmapStyleLayer' : 'HeatmapLayer';
-    case 'hillshade':
-      return isIOS ? 'MLNHillshadeStyleLayer' : 'HillshadeLayer';
-    case 'light':
-      return isIOS ? 'MLNLight' : 'Light';
-    default:
-      throw new Error(
-        `Is ${layer.name} a new layer? We should add support for it!`,
-      );
-  }
-};
-
-global.ifOrElseIf = function (index) {
-  if (index === 0) {
-    return 'if';
-  }
-  return '} else if';
-};
-
-global.iosStringArrayLiteral = function (arr) {
-  return `@[@${arr.map((item) => `"${item}"`).join(', @')}]`;
-};
-
-global.iosPropName = function (name) {
-  if (name.indexOf('visibility') !== -1) {
-    return 'visible';
-  }
-  if (name === 'fillExtrusionVerticalGradient') {
-    return 'fillExtrusionHasVerticalGradient';
-  }
-  if (iosPropNameOverrides[name]) {
-    return iosPropNameOverrides[name];
-  }
-  return name;
-};
-
-global.iosMapLibrePropName = function (name) {
-  let result = iosPropName(name);
-  if (result === 'fillExtrusionVerticalGradient') {
-    return 'fillExtrusionHasVerticalGradient';
-  }
-  return undefined;
-};
-
-global.iosPropMethodName = function (layer, name) {
-  if (name.indexOf('Visibility') !== -1) {
-    return pascelCase(layer.name) + 'StyleLayer' + name;
-  }
-  return name;
-};
-
-global.androidInputType = function (type, value) {
-  if (type === 'array' && value) {
-    return `${androidInputType(value)}[]`;
-  }
-
-  switch (type) {
-    case 'color':
-      return 'Integer';
-    case 'boolean':
-      return 'Boolean';
-    case 'number':
-      return 'Float';
-    default:
-      return 'String';
-  }
-};
-
-global.androidOutputType = function (type, value) {
-  if (type === 'array' && value) {
-    return `${androidOutputType(value)}[]`;
-  }
-
-  switch (type) {
-    case 'color':
-      return 'String';
-    case 'boolean':
-      return 'Boolean';
-    case 'number':
-      return 'Float';
-    default:
-      return 'String';
-  }
-};
-
-global.androidGetConfigType = function (androidType, prop) {
-  switch (androidType) {
-    case 'Integer':
-      return 'styleValue.getInt(VALUE_KEY)';
-    case 'Float':
-      return 'styleValue.getFloat(VALUE_KEY)';
-    case 'Boolean':
-      return 'styleValue.getBoolean(VALUE_KEY)';
-    case 'Float[]':
-      return 'styleValue.getFloatArray(VALUE_KEY)';
-    case 'String[]':
-      return 'styleValue.getStringArray(VALUE_KEY)';
-    default:
-      if (prop && prop.image) {
-        return 'styleValue.getImageURI()';
-      } else {
-        return 'styleValue.getString(VALUE_KEY)';
-      }
-  }
-};
-
-global.jsStyleType = function (prop) {
-  if (prop.type === 'color') {
-    return 'StyleTypes.Color';
-  }
-
-  if (prop.type === 'enum') {
-    return 'StyleTypes.Enum';
-  }
-
-  if (prop.type === 'string' && prop.image) {
-    return 'StyleTypes.Image';
-  }
-
-  if (prop.type === 'resolvedImage') {
-    return 'StyleTypes.Image';
-  }
-
-  if (prop.name.indexOf('Translate') !== -1) {
-    return 'StyleTypes.Translation';
-  }
-
-  return 'StyleTypes.Constant';
-};
-
-global.jsDocPropRequires = function (prop) {
-  if (!prop.doc.requires) {
-    return;
-  }
-
-  let desc = '';
-  for (let item of prop.doc.requires) {
-    if (typeof item === 'string') {
-      desc += item + ', ';
-    }
-  }
-
-  return desc;
-};
-
-global.getEnums = function (layers) {
-  let result = {};
-
-  layers.forEach((layer) => {
-    layer.properties.forEach((property) => {
-      if (
-        property.type === 'enum' ||
-        (property.type === 'array' && property.value === 'enum')
-      ) {
-        result[property.name] = {
-          values: property.doc.values,
-          name: property.name,
-        };
-      }
-    });
-  });
-  return Object.values(result);
-};
-
-
-global.dtsInterfaceType = function (prop) {
-  let propTypes = [];
-
-  if (prop.name.indexOf('Translate') !== -1 && prop.type != 'enum') {
-    propTypes.push('Translation');
-  } else if (prop.type === 'color') {
-    propTypes.push('string');
-    // propTypes.push('ConstantPropType');
-  } else if (prop.type === 'array') {
-    switch (prop.value) {
-      case 'number':
-        propTypes.push('number[]');
-        break;
-      case 'boolean':
-        propTypes.push('boolean[]');
-        break;
-      case 'string':
-        propTypes.push('string[]');
-        break;
-      case 'enum':
-        propTypes.push(
-          `Enum<${pascelCase(prop.name)}Enum, ${pascelCase(
-            prop.name,
-          )}EnumValues>[]`,
-        );
-        break;
-    }
-    // propTypes.push('ConstantPropType');
-  } else if (prop.type === 'number') {
-    propTypes.push('number');
-  } else if (prop.type === 'enum') {
-    propTypes.push(
-      `Enum<${pascelCase(prop.name)}Enum, ${pascelCase(prop.name)}EnumValues>`,
-    );
-  } else if (prop.type === 'boolean') {
-    propTypes.push('boolean');
-  } else if (prop.type === 'resolvedImage') {
-    propTypes.push('ResolvedImageType');
-  } else if (prop.type === 'formatted') {
-    propTypes.push('FormattedString');
-  } else if (prop.type === 'string') {
-    propTypes.push('string');
-  } else {
-    console.error('Unexpected type:', prop.type);
-    throw new Error(`Unexpected type: ${prop.type} for ${prop.name}`);
-  }
-
-  /*
-  if (prop.allowedFunctionTypes && prop.allowedFunctionTypes.length > 0) {
-    propTypes.push('StyleFunctionProps');
-  }
-  */
-
-  if (propTypes.length > 1) {
-    return `${propTypes.map((p) => startAtSpace(4, p)).join(' | ')},
-${startAtSpace(2, '')}`;
-  } else {
-    if (prop.expressionSupported) {
-      let params = '';
-      if (prop.expression && prop.expression.parameters) {
-        params = `,[${prop.expression.parameters
-          .map((v) => `'${v}'`)
-          .join(',')}]`;
-      }
-      return `Value<${propTypes[0]}${params}>`;
-    } else {
-      return propTypes[0];
-    }
-  }
-};
-
-global.jsDocReactProp = function (prop) {
-  let propTypes = [];
-
-  if (prop.type === 'color') {
-    propTypes.push('PropTypes.string');
-  } else if (prop.type === 'array') {
-    switch (prop.value) {
-      case 'number':
-        propTypes.push('PropTypes.arrayOf(PropTypes.number)');
-        break;
-      case 'boolean':
-        propTypes.push('PropTypes.arrayOf(PropTypes.bool)');
-        break;
-      case 'string':
-        propTypes.push('PropTypes.arrayOf(PropTypes.string)');
-        break;
-      default:
-        propTypes.push('PropTypes.array');
-    }
-  } else if (prop.type === 'number') {
-    propTypes.push('PropTypes.number');
-  } else if (prop.type === 'boolean') {
-    propTypes.push('PropTypes.bool');
-  } else if (prop.type === 'enum') {
-    if (prop.doc.values) {
-      propTypes.push(
-        `PropTypes.oneOf([${Object.keys(prop.doc.values)
-          .map((v) => `'${v}'`)
-          .join(', ')}])`,
-      );
-    } else {
-      propTypes.push('PropTypes.any');
-    }
-  } else {
-    // images can be required which result in a number
-    if (prop.image) {
-      propTypes.push('PropTypes.number');
-    }
-    propTypes.push('PropTypes.string');
-  }
-
-  if (prop.expressionSupported && !propTypes.includes('PropTypes.array')) {
-    propTypes.push('PropTypes.array');
-  }
-
-  if (propTypes.length > 1) {
-    return `PropTypes.oneOfType([
-${propTypes.map((p) => startAtSpace(4, p)).join(',\n')},
-${startAtSpace(2, '])')}`;
-  } else {
-    return propTypes[0];
-  }
-};
-
-global.startAtSpace = function (spaceCount, str) {
-  let value = '';
-
-  for (let i = 0; i < spaceCount; i++) {
-    value += ' ';
-  }
-
-  return `${value}${str}`;
-};
-
-global.replaceNewLine = function (str) {
-  if (str === undefined) {
-    return undefined;
-  }
-  if (str === null) {
-    return null;
-  }
-  return str.replace(/\n/g, '<br/>');
-};
-
-global.styleMarkdownTableRow = function (style) {
-  return `| \`${style.name}\` | \`${style.type}\` | \`${
-    style.requires.join(', ') || 'none'
-  }\` | \`${style.disabledBy.join(', ') || 'none'}\` | ${replaceNewLine(
-    style.description,
-  )} |`;
-};
-
-global.methodMarkdownTableRow = function (method) {
-  return method.params
-    .map((param) => {
-      return `| \`${param.name}\` | \`${
-        (param.type && param.type.name) || 'n/a'
-      }\` | \`${param.optional ? 'No' : 'Yes'}\` | ${replaceNewLine(
-        param.description,
-      )} |`;
-    })
-    .join('\n');
-};
-
-function _propMarkdownTableRows(props, prefix = '') {
-  return props
-    .map((prop) => {
-      let { type } = prop;
-      if (typeof type === 'object') {
-        type = type.name;
-      }
-      let defaultValue = prop.default || '';
-      let { description = '' } = prop;
-      let result = `| ${prefix}${
-        prop.name
-      } | \`${type}\` | \`${defaultValue}\` | \`${
-        prop.required
-      }\` | ${replaceNewLine(description)} |`;
-      if (type == 'shape') {
-        result = `${result}\n${_propMarkdownTableRows(
-          prop.type.value,
-          `&nbsp;&nbsp;${prefix}`,
-        )}`;
-      }
-      return result;
-    })
-    .join('\n');
-}
-global.propMarkdownTableRows = function (component) {
-  return _propMarkdownTableRows(component.props, '');
-};
-
-global.getMarkdownMethodSignature = function (method) {
-  const params = method.params
-    .map((param, i) => {
-      const isOptional = param.optional;
-
-      let name = '';
-
-      if (i !== 0) {
-        name += ', ';
-      }
-
-      name += param.name;
-      return isOptional ? `[${name}]` : name;
-    })
-    .join('');
-
-  return `${method.name}(${params})`;
-};
-
-global.getMarkdownMethodExamples = function (method) {
-  if (method.examples == null) {
-    return null;
-  }
-  return method.examples
-    .map((example) => {
-      return `
-
-\`\`\`javascript
-${example.trim()}
-\`\`\`
-
-`;
-    })
-    .join('');
-};
-
-global.getStyleDefaultValue = function (style) {
-  if (style.type === 'string' && style.default === '') {
-    return 'empty string';
-  } else if (style.type.includes('array')) {
-    return `[${style.default}]`;
-  } else {
-    return style.default;
-  }
-};
-
-Object.keys(iosSpecOverrides).forEach((propName) => {
-  const camelCasePropName = camelCase(propName);
-  iosPropNameOverrides[camelCasePropName] = camelCase(iosSpecOverrides[propName]);
-});

package/setup-jest.js

@@ -1,108 +0,0 @@
-import {NativeModules} from 'react-native';
-
-function keyMirror(keys) {
-  const obj = {};
-  keys.forEach(key => (obj[key] = key));
-  return obj;
-}
-
-// Mock of what the native code puts on the JS object
-NativeModules.MLNModule = {
-  // constants
-  UserTrackingModes: keyMirror([
-    'None',
-    'Follow',
-    'FollowWithCourse',
-    'FollowWithHeading',
-  ]),
-  StyleURL: keyMirror(['Default']),
-  EventTypes: keyMirror([
-    'MapClick',
-    'MapLongClick',
-    'RegionWillChange',
-    'RegionIsChanging',
-    'RegionDidChange',
-    'WillStartLoadingMap',
-    'DidFinishLoadingMap',
-    'DidFailLoadingMap',
-    'WillStartRenderingFrame',
-    'DidFinishRenderingFrame',
-    'DidFinishRenderingFrameFully',
-    'DidFinishLoadingStyle',
-    'SetCameraComplete',
-  ]),
-  CameraModes: keyMirror(['Flight', 'Ease', 'None']),
-  StyleSource: keyMirror(['DefaultSourceID']),
-  InterpolationMode: keyMirror([
-    'Exponential',
-    'Categorical',
-    'Interval',
-    'Identity',
-  ]),
-  LineJoin: keyMirror(['Bevel', 'Round', 'Miter']),
-  LineCap: keyMirror(['Butt', 'Round', 'Square']),
-  LineTranslateAnchor: keyMirror(['Map', 'Viewport']),
-  CirclePitchScale: keyMirror(['Map', 'Viewport']),
-  CircleTranslateAnchor: keyMirror(['Map', 'Viewport']),
-  FillExtrusionTranslateAnchor: keyMirror(['Map', 'Viewport']),
-  FillTranslateAnchor: keyMirror(['Map', 'Viewport']),
-  IconRotationAlignment: keyMirror(['Auto', 'Map', 'Viewport']),
-  IconTextFit: keyMirror(['None', 'Width', 'Height', 'Both']),
-  IconTranslateAnchor: keyMirror(['Map', 'Viewport']),
-  SymbolPlacement: keyMirror(['Line', 'Point']),
-  TextAnchor: keyMirror([
-    'Center',
-    'Left',
-    'Right',
-    'Top',
-    'Bottom',
-    'TopLeft',
-    'TopRight',
-    'BottomLeft',
-    'BottomRight',
-  ]),
-  TextJustify: keyMirror(['Center', 'Left', 'Right']),
-  TextPitchAlignment: keyMirror(['Auto', 'Map', 'Viewport']),
-  TextRotationAlignment: keyMirror(['Auto', 'Map', 'Viewport']),
-  TextTransform: keyMirror(['None', 'Lowercase', 'Uppercase']),
-  TextTranslateAnchor: keyMirror(['Map', 'Viewport']),
-  LightAnchor: keyMirror(['Map', 'Viewport']),
-  OfflinePackDownloadState: keyMirror(['Inactive', 'Active', 'Complete']),
-  OfflineCallbackName: keyMirror(['Progress', 'Error']),
-
-  // methods
-  setAccessToken: jest.fn(),
-  getAccessToken: () => Promise.resolve('test-token'),
-  setConnected: jest.fn(),
-};
-
-NativeModules.MLNOfflineModule = {
-  createPack: packOptions => {
-    return Promise.resolve({
-      bounds: packOptions.bounds,
-      metadata: JSON.stringify({name: packOptions.name}),
-    });
-  },
-  getPacks: () => Promise.resolve([]),
-  deletePack: () => Promise.resolve(),
-  getPackStatus: () => Promise.resolve({}),
-  pausePackDownload: () => Promise.resolve(),
-  resumePackDownload: () => Promise.resolve(),
-  setPackObserver: () => Promise.resolve(),
-  setTileCountLimit: jest.fn(),
-  setProgressEventThrottle: jest.fn(),
-};
-
-NativeModules.MLNSnapshotModule = {
-  takeSnap: () => {
-    return Promise.resolve('file://test.png');
-  },
-};
-
-NativeModules.MLNLocationModule = {
-  getLastKnownLocation: jest.fn(),
-  setMinDisplacement: jest.fn(),
-  start: jest.fn(),
-  stop: jest.fn(),
-  pause: jest.fn(),
-};