@slicemachine/init 1.1.9-alpha.2 → 1.1.10-alpha.1

package/build/index.js

@@ -23,6 +23,15 @@ const tmp = require('tmp');
 const AdmZip = require('adm-zip');
 const fsExtra = require('fs-extra');
 const fs = require('fs');
+const cookie = require('@slicemachine/core/build/utils/cookie');
+const Libraries = require('@slicemachine/core/build/libraries');
+const models = require('@slicemachine/core/build/models');
+const mime = require('mime');
+const snakeCase = require('lodash.snakecase');
+const FormData = require('form-data');
+const uniqid = require('uniqid');
+const customtypes = require('@prismicio/types-internal/lib/customtypes');
+const Either$1 = require('fp-ts/lib/Either');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -55,12 +64,18 @@ const hapi__namespace = /*#__PURE__*/_interopNamespace(hapi);
 const open__default = /*#__PURE__*/_interopDefaultLegacy(open);
 const NodeUtils__namespace = /*#__PURE__*/_interopNamespace(NodeUtils);
 const inquirer__namespace = /*#__PURE__*/_interopNamespace(inquirer);
+const inquirer__default = /*#__PURE__*/_interopDefaultLegacy(inquirer);
 const Separator__default = /*#__PURE__*/_interopDefaultLegacy(Separator);
 const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 const tmp__default = /*#__PURE__*/_interopDefaultLegacy(tmp);
 const AdmZip__default = /*#__PURE__*/_interopDefaultLegacy(AdmZip);
 const fsExtra__default = /*#__PURE__*/_interopDefaultLegacy(fsExtra);
 const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+const Libraries__namespace = /*#__PURE__*/_interopNamespace(Libraries);
+const mime__default = /*#__PURE__*/_interopDefaultLegacy(mime);
+const snakeCase__default = /*#__PURE__*/_interopDefaultLegacy(snakeCase);
+const FormData__default = /*#__PURE__*/_interopDefaultLegacy(FormData);
+const uniqid__default = /*#__PURE__*/_interopDefaultLegacy(uniqid);
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -80,13 +95,14 @@ var __privateSet = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var _client, _isTrackingActive, _anonymousId, _userId;
+var _client, _isTrackingActive, _anonymousId, _userId, _repository;
 class InitTracker {
   constructor() {
     __privateAdd(this, _client, null);
     __privateAdd(this, _isTrackingActive, true);
     __privateAdd(this, _anonymousId, "");
     __privateAdd(this, _userId, null);
+    __privateAdd(this, _repository, null);
   }
   initialize(segmentKey, isTrackingActive = true) {
     try {
@@ -99,18 +115,21 @@ class InitTracker {
     }
   }
   _trackEvent(eventType, attributes = {}) {
-    if (!this._isTrackingPossible(__privateGet(this, _client))) {
-      return;
-    }
-    const identifier = this._createSegmentIdentifier();
-    try {
-      __privateGet(this, _client).track({
+    return new Promise((resolve) => {
+      if (!this._isTrackingPossible(__privateGet(this, _client))) {
+        return resolve();
+      }
+      const identifier = this._createSegmentIdentifier();
+      const payload = {
         event: eventType,
         ...identifier,
-        properties: attributes
+        properties: attributes,
+        ...__privateGet(this, _repository) ? { context: { groupId: { Repository: __privateGet(this, _repository) } } } : {}
+      };
+      return __privateGet(this, _client).track(payload, () => {
+        return resolve();
       });
-    } catch (e) {
-    }
+    });
   }
   _identifyEvent(userId, intercomHash) {
     if (!this._isTrackingPossible(__privateGet(this, _client))) {
@@ -135,27 +154,31 @@ class InitTracker {
   _createSegmentIdentifier() {
     return !!__privateGet(this, _userId) ? { userId: __privateGet(this, _userId) } : { anonymousId: __privateGet(this, _anonymousId) };
   }
+  setRepository(repository) {
+    __privateSet(this, _repository, repository);
+  }
   identifyUser(userId, intercomHash) {
     __privateSet(this, _userId, userId);
-    this._identifyEvent(userId, intercomHash);
+    return this._identifyEvent(userId, intercomHash);
   }
   trackDownloadLibrary(library) {
-    this._trackEvent("SliceMachine Download Library" /* DownloadLibrary */, { library });
+    return this._trackEvent("SliceMachine Download Library" /* DownloadLibrary */, { library });
   }
-  trackInitIdentify(repoDomain) {
-    this._trackEvent("SliceMachine Init Identify" /* InitIdentify */, { repo: repoDomain });
+  trackInitIdentify() {
+    return this._trackEvent("SliceMachine Init Identify" /* InitIdentify */);
   }
   trackInitStart(repoDomain) {
-    this._trackEvent("SliceMachine Init Start" /* InitStart */, { repo: repoDomain });
+    return this._trackEvent("SliceMachine Init Start" /* InitStart */, { repo: repoDomain });
   }
-  trackInitDone(framework, repoDomain) {
-    this._trackEvent("SliceMachine Init Done" /* InitDone */, { framework, repo: repoDomain });
+  trackInitDone(framework) {
+    return this._trackEvent("SliceMachine Init Done" /* InitDone */, { framework });
   }
 }
 _client = new WeakMap();
 _isTrackingActive = new WeakMap();
 _anonymousId = new WeakMap();
 _userId = new WeakMap();
+_repository = new WeakMap();
 const Tracker = (() => {
   let smTrackerInstance;
   const init = () => new InitTracker();
@@ -395,16 +418,25 @@ function depsForFramework(framework) {
       return "";
   }
 }
-async function installRequiredDependencies(cwd, framework) {
-  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
-  const installDevDependencyCommand = yarnLock ? "yarn add -D" : "npm install --save-dev";
-  const installDependencyCommand = yarnLock ? "yarn add" : "npm install --save";
-  const spinner = spinner$1("Downloading Slice Machine");
-  spinner.start();
+async function addAndInstallDeps(framework, useYarn = false) {
+  const installDevDependencyCommand = useYarn ? "yarn add -D" : "npm install --save-dev";
+  const installDependencyCommand = useYarn ? "yarn add" : "npm install --save";
   const { stderr } = await execCommand(`${installDevDependencyCommand} ${SM_PACKAGE_NAME}`);
   const deps = depsForFramework(framework);
   if (deps)
     await execCommand(`${installDependencyCommand} ${deps}`);
+  return stderr;
+}
+async function installDeps(useYarn = false) {
+  const installCommand = useYarn ? "yarn" : "npm install";
+  const { stderr } = await execCommand(installCommand);
+  return stderr;
+}
+async function installRequiredDependencies(cwd, framework, skipDependencies) {
+  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
+  const spinner = spinner$1("Installing Slice Machine");
+  spinner.start();
+  const stderr = await (skipDependencies ? installDeps(yarnLock) : addAndInstallDeps(framework, yarnLock));
   const pathToPkg = path__default["default"].join(NodeUtils__namespace.PackagePaths(cwd).value(), SM_PACKAGE_NAME);
   const isPackageInstalled = NodeUtils__namespace.Files.exists(pathToPkg);
   if (isPackageInstalled || !stderr.length) {
@@ -663,18 +695,20 @@ async function loginOrBypass(base) {
 }
 
 const defaultSliceMachineVersion = "0.0.41";
-function configureProject(cwd, base, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
-  const spinner = spinner$1(`Configuring your ${framework.value} & Prismic project...`);
+async function configureProject(cwd, base, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
+  const frameworkName = NodeUtils__namespace.Framework.fancyName(framework.value);
+  const spinner = spinner$1(`Configuring your ${frameworkName} and Prismic project...`);
   spinner.start();
   try {
     const manifest = NodeUtils__namespace.retrieveManifest(cwd);
     const packageJson = NodeUtils__namespace.retrieveJsonPackage(cwd);
     const sliceMachineVersionInstalled = getTheSliceMachineVersionInstalled(packageJson);
     const manifestAlreadyExistWithContent = manifest.exists && manifest.content;
+    const libs = manifest.content && manifest.content.libraries && manifest.content.libraries.length > 0 ? manifest.content.libraries : ["@/slices"];
     const manifestUpdated = {
       ...manifestAlreadyExistWithContent ? manifest.content : { _latest: sliceMachineVersionInstalled },
       apiEndpoint: Prismic__namespace.Endpoints.buildRepositoryEndpoint(base, repositoryDomainName),
-      libraries: ["@/slices", ...sliceLibPath],
+      libraries: [...libs, ...sliceLibPath],
       ...framework.manuallyAdded ? { framework: framework.value } : {},
       ...!tracking ? { tracking } : {}
     };
@@ -683,10 +717,11 @@ function configureProject(cwd, base, repositoryDomainName, framework, sliceLibPa
     else
       NodeUtils__namespace.patchManifest(cwd, manifestUpdated);
     const pathToSlicesFolder = NodeUtils__namespace.CustomPaths(cwd).library("slices").value();
-    if (!NodeUtils__namespace.Files.exists(pathToSlicesFolder)) {
+    if (!NodeUtils__namespace.Files.exists(pathToSlicesFolder) && libs.includes("@/slices")) {
       NodeUtils__namespace.Files.mkdir(pathToSlicesFolder, { recursive: true });
     }
     NodeUtils__namespace.addJsonPackageSmScript(cwd);
+    await Tracker.get().trackInitDone(framework.value);
     spinner.succeed("Project configured! Ready to start");
   } catch (e) {
     spinner.fail("Failed to configure Slice Machine");
@@ -720,7 +755,8 @@ const extractVersionNumberFromSemver = (semver) => {
 function displayFinalMessage(cwd) {
   const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
   const command = `${yarnLock ? "yarn" : "npm"} run ${core.CONSTS.SCRIPT_NAME}`;
-  console.log(`${white("\u25A0")} Run ${purple(command)} to now launch Slice Machine`);
+  console.log();
+  console.log(`${white("\u25A0")} Run ${purple(command)} to start Slice Machine`);
 }
 
 const Dependencies = {
@@ -817,7 +853,7 @@ async function installLib(cwd, libGithubPath, branch = "HEAD") {
       return `~/${name}/${path2.replace("src/", "")}`;
     });
     spinner.succeed(`Slice library "${libGithubPath}" was installed successfully`);
-    Tracker.get().trackDownloadLibrary(libGithubPath);
+    void Tracker.get().trackDownloadLibrary(libGithubPath);
     return localLibs;
   } catch (error) {
     spinner.fail(`Error installing ${libGithubPath} lib!`);
@@ -828,6 +864,290 @@ async function installLib(cwd, libGithubPath, branch = "HEAD") {
   }
 }
 
+function handelErrors(prefix, err) {
+  if (axios__default["default"].isAxiosError(err) && err.response) {
+    writeError$1(`${prefix} | [${err.response.status}]: ${err.response.statusText}`);
+  } else if (err instanceof Error) {
+    writeError$1(`${prefix} ${err.message}`);
+  } else {
+    writeError$1(`${prefix} ${String(err)}`);
+  }
+}
+async function getRemoteSliceIds(customTypeApiEndpoint, repository, authorization) {
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/slices`;
+  return axios__default["default"].get(addr, {
+    headers: {
+      Authorization: `Bearer ${authorization}`,
+      repository
+    }
+  }).then((res) => {
+    return Array.isArray(res.data) ? res.data.map((model) => model.id) : [];
+  });
+}
+async function sendModelToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, model) {
+  const data = models.Slices.fromSM(model);
+  const updateOrInsertUrl = `${customTypesApiEndpoint}slices/${remoteSliceIds.includes(model.id) ? "update" : "insert"}`;
+  return axios__default["default"].post(updateOrInsertUrl, data, {
+    headers: {
+      Authorization: `Bearer ${authorization}`,
+      repository
+    }
+  }).then(() => {
+    return;
+  }).catch((err) => {
+    handelErrors(`sending slice ${model.id},  please try again. If the problem persists, contact us.`, err);
+    throw err;
+  });
+}
+async function sendManyModelsToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, models) {
+  return Promise.all(models.map((model) => sendModelToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, model))).then(() => {
+    return;
+  }).catch(() => {
+    process.exit(1);
+  });
+}
+function stripLastSlash(str) {
+  return str.replace(/\/*$/g, "");
+}
+function getRemoteCustomTypeIds(customTypeApiEndpoint, repository, authorization) {
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes`;
+  return axios__default["default"].get(addr, {
+    headers: {
+      Authorization: `Bearer ${authorization}`,
+      repository
+    }
+  }).then((res) => {
+    return Array.isArray(res.data) ? res.data.map((ct) => ct.id) : [];
+  });
+}
+async function sendCustomTypeToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customType) {
+  const shouldUpdate = remoteCustomTypeIds.includes(customType.id);
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes/${shouldUpdate ? "update" : "insert"}`;
+  return axios__default["default"].post(addr, customType, {
+    headers: {
+      repository,
+      Authorization: `Bearer ${authorization}`
+    }
+  }).then(() => {
+    return;
+  }).catch((err) => {
+    handelErrors(`sending custom type ${customType.id}, please try again. If the problem persists, contact us.`, err);
+    throw err;
+  });
+}
+async function sendManyCustomTypesToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customTypes) {
+  return Promise.all(customTypes.map((customType) => sendCustomTypeToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customType))).then(() => {
+    return;
+  }).catch(() => {
+    process.exit(1);
+  });
+}
+
+const ProductionApisEndpoints = {
+  Models: "https://customtypes.prismic.io/",
+  AclProvider: "https://0yyeb2g040.execute-api.us-east-1.amazonaws.com/prod/"
+};
+const StageApisEndpoints = {
+  Models: "https://customtypes.wroom.io/",
+  AclProvider: "https://2iamcvnxf4.execute-api.us-east-1.amazonaws.com/stage/"
+};
+const getEndpointsFromBase = (base) => {
+  const url = new URL(base);
+  if (url.hostname === "wroom.io")
+    return StageApisEndpoints;
+  return ProductionApisEndpoints;
+};
+
+async function promptToPushSlices() {
+  return inquirer__default["default"].prompt([
+    {
+      type: "confirm",
+      name: "pushSlices",
+      default: false,
+      message: "Your repository already contains Slices. Do you want to continue pushing your local Slices?"
+    }
+  ]).then((res) => res.pushSlices);
+}
+async function promptToPushCustomTypes() {
+  return inquirer__default["default"].prompt([
+    {
+      type: "confirm",
+      name: "pushCustomTypes",
+      default: false,
+      message: "Your repository already contains Custom Types. Do you want to continue pushing your local Slices?"
+    }
+  ]).then((res) => res.pushCustomTypes);
+}
+
+async function createAcl(address, repository, authorization) {
+  return axios__default["default"].get(address + "create", {
+    headers: {
+      repository,
+      Authorization: `Bearer ${authorization}`,
+      "User-Agent": "slice-machine"
+    }
+  }).then((res) => res.data);
+}
+async function createFormForS3(key, filename, filePath, acl) {
+  const form = new FormData__default["default"]();
+  Object.entries(acl.values.fields).forEach(([k, value]) => {
+    form.append(k, value);
+  });
+  form.append("key", key);
+  const contentType = mime__default["default"].getType(filePath);
+  contentType && form.append("Content-Type", contentType);
+  return fs__default["default"].promises.readFile(filePath).then((file) => {
+    form.append("file", file, { filename });
+    return form;
+  }).catch(() => {
+    writeError$1(`Error reading preview image: ${filename}`);
+    return null;
+  });
+}
+function createS3Key(repository, sliceName, variationId, filename) {
+  return `${repository}/shared-slices/${snakeCase__default["default"](sliceName)}/${snakeCase__default["default"](variationId)}-${uniqid__default["default"]()}/${filename}`;
+}
+async function sendVariationPreviewToS3(acl, repository, sliceName, variationId, filePath) {
+  const filename = path__default["default"].basename(filePath);
+  const key = createS3Key(repository, sliceName, variationId, filename);
+  const form = await createFormForS3(key, filename, filePath, acl);
+  if (form === null)
+    return null;
+  if (form.hasKnownLength() === false) {
+    writeError$1(`[slice/push] An error occurred while uploading preview image ${filePath} as length in unknown`);
+  }
+  const errorMessage = `[slice/push] An error occurred while uploading preview images for ${sliceName}-${variationId} - please contact support`;
+  return axios__default["default"].post(acl.values.url, form, {
+    headers: {
+      ...form.getHeaders(),
+      "Content-Length": String(form.getLengthSync())
+    }
+  }).then((res) => {
+    if (res.status !== 204) {
+      writeError$1(errorMessage);
+      writeError$1(`${res.status}: ${res.statusText}`);
+      return null;
+    } else {
+      return `${acl.imgixEndpoint}/${key}`;
+    }
+  }).catch((err) => {
+    writeError$1(errorMessage);
+    if (axios__default["default"].isAxiosError(err) && err.response) {
+      writeError$1(`${err.response.status}: ${err.response.statusText}`);
+    } else if (err instanceof Error) {
+      writeError$1(err.message);
+    } else {
+      writeError$1(String(err));
+    }
+    return null;
+  });
+}
+async function maybeAddImageUrlToVariation(acl, repository, modelId, pathToScreenShot, variation) {
+  const imageUrl = await sendVariationPreviewToS3(acl, repository, modelId, variation.id, pathToScreenShot);
+  if (!imageUrl)
+    return variation;
+  return {
+    ...variation,
+    imageUrl
+  };
+}
+async function addImageUrlsToVariations(acl, repository, modelId, screenshotPaths, variations) {
+  return Promise.all(variations.map(async (variation) => {
+    const screenshot = screenshotPaths[variation.id];
+    if (!screenshot || !screenshot.path)
+      return variation;
+    return maybeAddImageUrlToVariation(acl, repository, modelId, screenshot.path, variation);
+  }));
+}
+async function maybeUpdateModelVariationsWithImageUrl(acl, repository, component) {
+  const { screenshotPaths, model } = component;
+  const variations = await addImageUrlsToVariations(acl, repository, model.id, screenshotPaths, model.variations);
+  return {
+    ...model,
+    variations
+  };
+}
+async function addImageUrlsToModelVariations(acl, repository, components) {
+  return Promise.all(components.map(async (component) => maybeUpdateModelVariationsWithImageUrl(acl, repository, component)));
+}
+
+async function sendSlicesFromStarter(base, repository, authorization, libraryPaths, cwd) {
+  const endpoints = getEndpointsFromBase(base);
+  const libraries = Libraries__namespace.libraries(cwd, libraryPaths);
+  if (libraries.length === 0)
+    return Promise.resolve(false);
+  const remoteSlices = await getRemoteSliceIds(endpoints.Models, repository, authorization);
+  if (remoteSlices.length) {
+    const pushAnyway = await promptToPushSlices();
+    if (pushAnyway === false)
+      return Promise.resolve(true);
+  }
+  const spinner = spinner$1("Pushing existing Slice models to your repository");
+  spinner.start();
+  const acl = await createAcl(endpoints.AclProvider, repository, authorization);
+  const components = libraries.reduce((acc, lib) => {
+    return [...acc, ...lib.components];
+  }, []);
+  const models = await addImageUrlsToModelVariations(acl, repository, components);
+  await sendManyModelsToPrismic(repository, authorization, endpoints.Models, remoteSlices, models);
+  spinner.succeed();
+  return Promise.resolve(true);
+}
+
+function readCustomTypes(cwd) {
+  const customTypePaths = NodeUtils.CustomTypesPaths(cwd);
+  const dir = customTypePaths.value();
+  if (NodeUtils.Files.isDirectory(dir) === false)
+    return [];
+  const fileNames = NodeUtils.Files.readDirectory(dir);
+  const files = fileNames.reduce((acc, fileName) => {
+    const filePath = customTypePaths.customType(fileName).model();
+    const json = NodeUtils.Files.safeReadJson(filePath);
+    if (!json)
+      return acc;
+    const file = customtypes.CustomType.decode(json);
+    if (file instanceof Error) {
+      writeError$1(`reading ${filePath}: ${file.message}`);
+      return acc;
+    }
+    if (Either$1.isLeft(file)) {
+      writeError$1(`validating ${filePath}: ${JSON.stringify(file.left)}`);
+      return acc;
+    }
+    return [...acc, file.right];
+  }, []);
+  return files;
+}
+async function sendCustomTypesFromStarter(repository, authorization, base, cwd) {
+  const customTypeApiEndpoint = getEndpointsFromBase(base).Models;
+  const customTypes = readCustomTypes(cwd);
+  if (customTypes.length === 0)
+    return Promise.resolve(false);
+  const remoteCustomTypeIds = await getRemoteCustomTypeIds(customTypeApiEndpoint, repository, authorization);
+  if (remoteCustomTypeIds.length) {
+    const shouldPush = await promptToPushCustomTypes();
+    if (shouldPush === false)
+      return Promise.resolve(false);
+  }
+  const spinner = spinner$1("Pushing existing custom types to your repository");
+  spinner.start();
+  await sendManyCustomTypesToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customTypes);
+  spinner.succeed();
+  return Promise.resolve(true);
+}
+
+async function sendStarterData(repository, base, cookies, cwd) {
+  const smJson = NodeUtils.retrieveManifest(cwd);
+  const hasDocuments = NodeUtils.Files.exists(path__default["default"].join(cwd, "documents"));
+  if (smJson.exists === false || hasDocuments === false)
+    return Promise.resolve(false);
+  const authTokenFromCookie = cookie.parsePrismicAuthToken(cookies);
+  if (smJson.content && smJson.content.libraries) {
+    await sendSlicesFromStarter(base, repository, authTokenFromCookie, smJson.content.libraries, cwd);
+  }
+  return sendCustomTypesFromStarter(repository, authTokenFromCookie, base, cwd);
+}
+
 async function init() {
   const cwd = findArgument(process.argv, "cwd") || process.cwd();
   const base = findArgument(process.argv, "base") || core.CONSTS.DEFAULT_BASE;
@@ -836,7 +1156,7 @@ async function init() {
   const isTrackingAvailable = findArgument(process.argv, "tracking") !== "false";
   const maybeRepositorySubdomain = findArgument(process.argv, "repository");
   Tracker.get().initialize("JfTfmHaATChc4xueS7RcCBsixI71dJIJ" , isTrackingAvailable);
-  Tracker.get().trackInitStart(maybeRepositorySubdomain);
+  void Tracker.get().trackInitStart(maybeRepositorySubdomain);
   console.log(purple("You're about to configure Slicemachine... Press ctrl + C to cancel"));
   validatePkg(cwd);
   const user = await loginOrBypass(base);
@@ -845,14 +1165,15 @@ async function init() {
   if (user.profile) {
     Tracker.get().identifyUser(user.profile.shortId, user.profile.intercomHash);
   }
-  Tracker.get().trackInitIdentify(maybeRepositorySubdomain);
+  void Tracker.get().trackInitIdentify();
   const config = Prismic__default["default"].PrismicSharedConfigManager.get();
   const frameworkResult = await detectFramework(cwd);
   const repositoryDomainName = await chooseOrCreateARepository(cwd, frameworkResult.value, config.cookies, config.base, maybeRepositorySubdomain);
-  await installRequiredDependencies(cwd, frameworkResult.value);
+  Tracker.get().setRepository(repositoryDomainName);
   const sliceLibPath = lib ? await installLib(cwd, lib, branch) : void 0;
-  configureProject(cwd, base, repositoryDomainName, frameworkResult, sliceLibPath, isTrackingAvailable);
-  Tracker.get().trackInitDone(frameworkResult.value, repositoryDomainName);
+  const wasStarter = await sendStarterData(repositoryDomainName, config.base, config.cookies, cwd);
+  await configureProject(cwd, base, repositoryDomainName, frameworkResult, sliceLibPath, isTrackingAvailable);
+  await installRequiredDependencies(cwd, frameworkResult.value, wasStarter);
   displayFinalMessage(cwd);
 }
 init().then(() => {