create-expo-cljs-app
Version:
Create a react native application with Expo and Shadow-CLJS!
329 lines (278 loc) • 8.46 kB
JavaScript
/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
* @format
*/
;
function _slicedToArray(arr, i) {
return (
_arrayWithHoles(arr) ||
_iterableToArrayLimit(arr, i) ||
_unsupportedIterableToArray(arr, i) ||
_nonIterableRest()
);
}
function _nonIterableRest() {
throw new TypeError(
"Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
);
}
function _iterableToArrayLimit(arr, i) {
if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr)))
return;
var _arr = [];
var _n = true;
var _d = false;
var _e = undefined;
try {
for (
var _i = arr[Symbol.iterator](), _s;
!(_n = (_s = _i.next()).done);
_n = true
) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) return arr;
}
function _toConsumableArray(arr) {
return (
_arrayWithoutHoles(arr) ||
_iterableToArray(arr) ||
_unsupportedIterableToArray(arr) ||
_nonIterableSpread()
);
}
function _nonIterableSpread() {
throw new TypeError(
"Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
);
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
return _arrayLikeToArray(o, minLen);
}
function _iterableToArray(iter) {
if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
return Array.from(iter);
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
const vlq = require("vlq");
const _require = require("metro-source-map"),
normalizeSourcePath = _require.normalizeSourcePath;
const METADATA_FIELD_FUNCTIONS = 0;
/**
* Consumes the `x_facebook_sources` metadata field from a source map and
* exposes various queries on it.
*
* By default, source names are normalized using the same logic that the
* `source-map@0.5.6` package uses internally. This is crucial for keeping the
* sources list in sync with a `SourceMapConsumer` instance.
* If you're using this with a different source map reader (e.g. one that
* doesn't normalize source names at all), you can switch out the normalization
* function in the constructor, e.g.
*
* new SourceMetadataMapConsumer(map, source => source) // Don't normalize
*/
class SourceMetadataMapConsumer {
constructor(map) {
let normalizeSourceFn =
arguments.length > 1 && arguments[1] !== undefined
? arguments[1]
: normalizeSourcePath;
this._sourceMap = map;
this._decodedFunctionMapCache = new Map();
this._normalizeSource = normalizeSourceFn;
}
/**
* Retrieves a human-readable name for the function enclosing a particular
* source location.
*
* When used with the `source-map` package, you'll first use
* `SourceMapConsumer#originalPositionFor` to retrieve a source location,
* then pass that location to `functionNameFor`.
*/
functionNameFor(_ref) {
let line = _ref.line,
column = _ref.column,
source = _ref.source;
if (source && line != null && column != null) {
const mappings = this._getFunctionMappings(source);
if (mappings) {
const mapping = findEnclosingMapping(mappings, {
line,
column
});
if (mapping) {
return mapping.name;
}
}
}
return null;
}
/**
* Returns this map's source metadata as a new array with the same order as
* `sources`.
*
* This array can be used as the `x_facebook_sources` field of a map whose
* `sources` field is the array that was passed into this method.
*/
toArray(sources) {
const metadataBySource = this._getMetadataBySource();
const encoded = [];
for (const source of sources) {
encoded.push(metadataBySource[source] || null);
}
return encoded;
}
/**
* Prepares and caches a lookup table of metadata by source name.
*/
_getMetadataBySource() {
if (!this._metadataBySource) {
this._metadataBySource = this._getMetadataObjectsBySourceNames(
this._sourceMap
);
}
return this._metadataBySource;
}
/**
* Decodes the function name mappings for the given source if needed, and
* retrieves a sorted, searchable array of mappings.
*/
_getFunctionMappings(source) {
if (this._decodedFunctionMapCache.has(source)) {
return this._decodedFunctionMapCache.get(source);
}
let parsedFunctionMap = null;
const metadataBySource = this._getMetadataBySource();
if (Object.prototype.hasOwnProperty.call(metadataBySource, source)) {
const metadata = metadataBySource[source] || [];
parsedFunctionMap = decodeFunctionMap(metadata[METADATA_FIELD_FUNCTIONS]);
}
this._decodedFunctionMapCache.set(source, parsedFunctionMap);
return parsedFunctionMap;
}
/**
* Collects source metadata from the given map using the current source name
* normalization function. Handles both index maps (with sections) and plain
* maps.
*
* NOTE: If any sources are repeated in the map (which shouldn't happen in
* Metro, but is technically possible because of index maps) we only keep the
* metadata from the last occurrence of any given source.
*/
_getMetadataObjectsBySourceNames(map) {
// eslint-disable-next-line lint/strictly-null
if (map.mappings === undefined) {
const indexMap = map;
return Object.assign.apply(
Object,
[{}].concat(
_toConsumableArray(
indexMap.sections.map(section =>
this._getMetadataObjectsBySourceNames(section.map)
)
)
)
);
}
if ("x_facebook_sources" in map) {
const basicMap = map;
return (basicMap.x_facebook_sources || []).reduce(
(acc, metadata, index) => {
let source = basicMap.sources[index];
if (source != null) {
source = this._normalizeSource(source, basicMap);
acc[source] = metadata;
}
return acc;
},
{}
);
}
return {};
}
}
function decodeFunctionMap(functionMap) {
if (!functionMap) {
return [];
}
const parsed = [];
let line = 1;
let nameIndex = 0;
for (const lineMappings of functionMap.mappings.split(";")) {
let column = 0;
for (const mapping of lineMappings.split(",")) {
const _vlq$decode = vlq.decode(mapping),
_vlq$decode2 = _slicedToArray(_vlq$decode, 3),
columnDelta = _vlq$decode2[0],
nameDelta = _vlq$decode2[1],
_vlq$decode2$ = _vlq$decode2[2],
lineDelta = _vlq$decode2$ === void 0 ? 0 : _vlq$decode2$;
line += lineDelta;
nameIndex += nameDelta;
column += columnDelta;
parsed.push({
line,
column,
name: functionMap.names[nameIndex]
});
}
}
return parsed;
}
function findEnclosingMapping(mappings, target) {
let first = 0;
let it = 0;
let count = mappings.length;
let step;
while (count > 0) {
it = first;
step = Math.floor(count / 2);
it += step;
if (comparePositions(target, mappings[it]) >= 0) {
first = ++it;
count -= step + 1;
} else {
count = step;
}
}
return first ? mappings[first - 1] : null;
}
function comparePositions(a, b) {
if (a.line === b.line) {
return a.column - b.column;
}
return a.line - b.line;
}
module.exports = SourceMetadataMapConsumer;