1"use strict";
2
3Object.defineProperty(exports, "__esModule", {
4  value: true
5});
6exports.addMetaDataItemToMainApplication = addMetaDataItemToMainApplication;
7exports.addUsesLibraryItemToMainApplication = addUsesLibraryItemToMainApplication;
8exports.ensureToolsAvailable = ensureToolsAvailable;
9exports.findMetaDataItem = findMetaDataItem;
10exports.findUsesLibraryItem = findUsesLibraryItem;
11exports.getMainActivity = getMainActivity;
12exports.getMainActivityOrThrow = getMainActivityOrThrow;
13exports.getMainApplication = getMainApplication;
14exports.getMainApplicationMetaDataValue = getMainApplicationMetaDataValue;
15exports.getMainApplicationOrThrow = getMainApplicationOrThrow;
16exports.getRunnableActivity = getRunnableActivity;
17exports.prefixAndroidKeys = prefixAndroidKeys;
18exports.readAndroidManifestAsync = readAndroidManifestAsync;
19exports.removeMetaDataItemFromMainApplication = removeMetaDataItemFromMainApplication;
20exports.removeUsesLibraryItemFromMainApplication = removeUsesLibraryItemFromMainApplication;
21exports.writeAndroidManifestAsync = writeAndroidManifestAsync;
22
23function _assert() {
24  const data = _interopRequireDefault(require("assert"));
25
26  _assert = function () {
27    return data;
28  };
29
30  return data;
31}
32
33function _fs() {
34  const data = _interopRequireDefault(require("fs"));
35
36  _fs = function () {
37    return data;
38  };
39
40  return data;
41}
42
43function _path() {
44  const data = _interopRequireDefault(require("path"));
45
46  _path = function () {
47    return data;
48  };
49
50  return data;
51}
52
53function XML() {
54  const data = _interopRequireWildcard(require("../utils/XML"));
55
56  XML = function () {
57    return data;
58  };
59
60  return data;
61}
62
63function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
64
65function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
66
67function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
68
69async function writeAndroidManifestAsync(manifestPath, androidManifest) {
70  const manifestXml = XML().format(androidManifest);
71  await _fs().default.promises.mkdir(_path().default.dirname(manifestPath), {
72    recursive: true
73  });
74  await _fs().default.promises.writeFile(manifestPath, manifestXml);
75}
76
77async function readAndroidManifestAsync(manifestPath) {
78  const xml = await XML().readXMLAsync({
79    path: manifestPath
80  });
81
82  if (!isManifest(xml)) {
83    throw new Error('Invalid manifest found at: ' + manifestPath);
84  }
85
86  return xml;
87}
88
89function isManifest(xml) {
90  // TODO: Maybe more validation
91  return !!xml.manifest;
92}
93/** Returns the `manifest.application` tag ending in `.MainApplication` */
94
95
96function getMainApplication(androidManifest) {
97  var _androidManifest$mani, _androidManifest$mani2, _androidManifest$mani3;
98
99  return (_androidManifest$mani = androidManifest === null || androidManifest === void 0 ? void 0 : (_androidManifest$mani2 = androidManifest.manifest) === null || _androidManifest$mani2 === void 0 ? void 0 : (_androidManifest$mani3 = _androidManifest$mani2.application) === null || _androidManifest$mani3 === void 0 ? void 0 : _androidManifest$mani3.filter(e => {
100    var _e$$;
101
102    return e === null || e === void 0 ? void 0 : (_e$$ = e.$) === null || _e$$ === void 0 ? void 0 : _e$$['android:name'].endsWith('.MainApplication');
103  })[0]) !== null && _androidManifest$mani !== void 0 ? _androidManifest$mani : null;
104}
105
106function getMainApplicationOrThrow(androidManifest) {
107  const mainApplication = getMainApplication(androidManifest);
108  (0, _assert().default)(mainApplication, 'AndroidManifest.xml is missing the required MainApplication element');
109  return mainApplication;
110}
111
112function getMainActivityOrThrow(androidManifest) {
113  const mainActivity = getMainActivity(androidManifest);
114  (0, _assert().default)(mainActivity, 'AndroidManifest.xml is missing the required MainActivity element');
115  return mainActivity;
116}
117
118function getRunnableActivity(androidManifest) {
119  var _androidManifest$mani4, _androidManifest$mani5, _androidManifest$mani6, _androidManifest$mani7, _androidManifest$mani8;
120
121  // Get enabled activities
122  const enabledActivities = androidManifest === null || androidManifest === void 0 ? void 0 : (_androidManifest$mani4 = androidManifest.manifest) === null || _androidManifest$mani4 === void 0 ? void 0 : (_androidManifest$mani5 = _androidManifest$mani4.application) === null || _androidManifest$mani5 === void 0 ? void 0 : (_androidManifest$mani6 = _androidManifest$mani5[0]) === null || _androidManifest$mani6 === void 0 ? void 0 : (_androidManifest$mani7 = _androidManifest$mani6.activity) === null || _androidManifest$mani7 === void 0 ? void 0 : (_androidManifest$mani8 = _androidManifest$mani7.filter) === null || _androidManifest$mani8 === void 0 ? void 0 : _androidManifest$mani8.call(_androidManifest$mani7, e => e.$['android:enabled'] !== 'false' && e.$['android:enabled'] !== false);
123
124  if (!enabledActivities) {
125    return null;
126  } // Get the activity that has a runnable intent-filter
127
128
129  for (const activity of enabledActivities) {
130    if (Array.isArray(activity['intent-filter'])) {
131      for (const intentFilter of activity['intent-filter']) {
132        var _intentFilter$action, _intentFilter$categor;
133
134        if ((_intentFilter$action = intentFilter.action) !== null && _intentFilter$action !== void 0 && _intentFilter$action.find(action => action.$['android:name'] === 'android.intent.action.MAIN') && (_intentFilter$categor = intentFilter.category) !== null && _intentFilter$categor !== void 0 && _intentFilter$categor.find(category => category.$['android:name'] === 'android.intent.category.LAUNCHER')) {
135          return activity;
136        }
137      }
138    }
139  }
140
141  return null;
142}
143
144function getMainActivity(androidManifest) {
145  var _androidManifest$mani9, _androidManifest$mani10, _androidManifest$mani11, _androidManifest$mani12, _androidManifest$mani13, _mainActivity$;
146
147  const mainActivity = androidManifest === null || androidManifest === void 0 ? void 0 : (_androidManifest$mani9 = androidManifest.manifest) === null || _androidManifest$mani9 === void 0 ? void 0 : (_androidManifest$mani10 = _androidManifest$mani9.application) === null || _androidManifest$mani10 === void 0 ? void 0 : (_androidManifest$mani11 = _androidManifest$mani10[0]) === null || _androidManifest$mani11 === void 0 ? void 0 : (_androidManifest$mani12 = _androidManifest$mani11.activity) === null || _androidManifest$mani12 === void 0 ? void 0 : (_androidManifest$mani13 = _androidManifest$mani12.filter) === null || _androidManifest$mani13 === void 0 ? void 0 : _androidManifest$mani13.call(_androidManifest$mani12, e => e.$['android:name'] === '.MainActivity');
148  return (_mainActivity$ = mainActivity === null || mainActivity === void 0 ? void 0 : mainActivity[0]) !== null && _mainActivity$ !== void 0 ? _mainActivity$ : null;
149}
150
151function addMetaDataItemToMainApplication(mainApplication, itemName, itemValue, itemType = 'value') {
152  let existingMetaDataItem;
153  const newItem = {
154    $: prefixAndroidKeys({
155      name: itemName,
156      [itemType]: itemValue
157    })
158  };
159
160  if (mainApplication['meta-data']) {
161    existingMetaDataItem = mainApplication['meta-data'].filter(e => e.$['android:name'] === itemName);
162
163    if (existingMetaDataItem.length) {
164      existingMetaDataItem[0].$[`android:${itemType}`] = itemValue;
165    } else {
166      mainApplication['meta-data'].push(newItem);
167    }
168  } else {
169    mainApplication['meta-data'] = [newItem];
170  }
171
172  return mainApplication;
173}
174
175function removeMetaDataItemFromMainApplication(mainApplication, itemName) {
176  const index = findMetaDataItem(mainApplication, itemName);
177
178  if (mainApplication !== null && mainApplication !== void 0 && mainApplication['meta-data'] && index > -1) {
179    mainApplication['meta-data'].splice(index, 1);
180  }
181
182  return mainApplication;
183}
184
185function findApplicationSubItem(mainApplication, category, itemName) {
186  const parent = mainApplication[category];
187
188  if (Array.isArray(parent)) {
189    const index = parent.findIndex(e => e.$['android:name'] === itemName);
190    return index;
191  }
192
193  return -1;
194}
195
196function findMetaDataItem(mainApplication, itemName) {
197  return findApplicationSubItem(mainApplication, 'meta-data', itemName);
198}
199
200function findUsesLibraryItem(mainApplication, itemName) {
201  return findApplicationSubItem(mainApplication, 'uses-library', itemName);
202}
203
204function getMainApplicationMetaDataValue(androidManifest, name) {
205  const mainApplication = getMainApplication(androidManifest);
206
207  if (mainApplication !== null && mainApplication !== void 0 && mainApplication.hasOwnProperty('meta-data')) {
208    var _mainApplication$meta, _item$$$androidValue;
209
210    const item = mainApplication === null || mainApplication === void 0 ? void 0 : (_mainApplication$meta = mainApplication['meta-data']) === null || _mainApplication$meta === void 0 ? void 0 : _mainApplication$meta.find(e => e.$['android:name'] === name);
211    return (_item$$$androidValue = item === null || item === void 0 ? void 0 : item.$['android:value']) !== null && _item$$$androidValue !== void 0 ? _item$$$androidValue : null;
212  }
213
214  return null;
215}
216
217function addUsesLibraryItemToMainApplication(mainApplication, item) {
218  let existingMetaDataItem;
219  const newItem = {
220    $: prefixAndroidKeys(item)
221  };
222
223  if (mainApplication['uses-library']) {
224    existingMetaDataItem = mainApplication['uses-library'].filter(e => e.$['android:name'] === item.name);
225
226    if (existingMetaDataItem.length) {
227      existingMetaDataItem[0].$ = newItem.$;
228    } else {
229      mainApplication['uses-library'].push(newItem);
230    }
231  } else {
232    mainApplication['uses-library'] = [newItem];
233  }
234
235  return mainApplication;
236}
237
238function removeUsesLibraryItemFromMainApplication(mainApplication, itemName) {
239  const index = findUsesLibraryItem(mainApplication, itemName);
240
241  if (mainApplication !== null && mainApplication !== void 0 && mainApplication['uses-library'] && index > -1) {
242    mainApplication['uses-library'].splice(index, 1);
243  }
244
245  return mainApplication;
246}
247
248function prefixAndroidKeys(head) {
249  // prefix all keys with `android:`
250  return Object.entries(head).reduce((prev, [key, curr]) => ({ ...prev,
251    [`android:${key}`]: curr
252  }), {});
253}
254/**
255 * Ensure the `tools:*` namespace is available in the manifest.
256 *
257 * @param manifest AndroidManifest.xml
258 * @returns manifest with the `tools:*` namespace available
259 */
260
261
262function ensureToolsAvailable(manifest) {
263  return ensureManifestHasNamespace(manifest, {
264    namespace: 'xmlns:tools',
265    url: 'http://schemas.android.com/tools'
266  });
267}
268/**
269 * Ensure a particular namespace is available in the manifest.
270 *
271 * @param manifest `AndroidManifest.xml`
272 * @returns manifest with the provided namespace available
273 */
274
275
276function ensureManifestHasNamespace(manifest, {
277  namespace,
278  url
279}) {
280  var _manifest$manifest, _manifest$manifest$$;
281
282  if (manifest !== null && manifest !== void 0 && (_manifest$manifest = manifest.manifest) !== null && _manifest$manifest !== void 0 && (_manifest$manifest$$ = _manifest$manifest.$) !== null && _manifest$manifest$$ !== void 0 && _manifest$manifest$$[namespace]) {
283    return manifest;
284  }
285
286  manifest.manifest.$[namespace] = url;
287  return manifest;
288}
289//# sourceMappingURL=Manifest.js.map