@teambit/tracker 0.0.1

package/dist/add-cmd.d.ts

@@ -0,0 +1,22 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { TrackerMain } from './tracker.main.runtime';
+export declare class AddCmd implements Command {
+    private tracker;
+    name: string;
+    description: string;
+    group: string;
+    extendedDescription: string;
+    helpUrl: string;
+    alias: string;
+    options: CommandOptions;
+    loader: boolean;
+    migration: boolean;
+    constructor(tracker: TrackerMain);
+    report([paths]: [string[]], { id, main, namespace, scope, override, }: {
+        id: string | null | undefined;
+        main: string | null | undefined;
+        namespace: string | null | undefined;
+        scope?: string;
+        override: boolean;
+    }): Promise<string>;
+}

package/dist/add-cmd.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AddCmd = void 0;
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+  _defineProperty2 = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function path() {
+  const data = _interopRequireWildcard(require("path"));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _ramda() {
+  const data = _interopRequireDefault(require("ramda"));
+  _ramda = function () {
+    return data;
+  };
+  return data;
+}
+function _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); }
+function _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; }
+class AddCmd {
+  constructor(tracker) {
+    this.tracker = tracker;
+    (0, _defineProperty2().default)(this, "name", 'add [path...]');
+    (0, _defineProperty2().default)(this, "description", 'Add any subset of files to be tracked as a component(s).');
+    (0, _defineProperty2().default)(this, "group", 'development');
+    (0, _defineProperty2().default)(this, "extendedDescription", 'Learn the recommended workflow for tracking directories as components, in the link below.');
+    (0, _defineProperty2().default)(this, "helpUrl", 'docs/workspace/creating-workspaces?new_existing_project=1');
+    (0, _defineProperty2().default)(this, "alias", 'a');
+    (0, _defineProperty2().default)(this, "options", [['i', 'id <name>', 'manually set component id'], ['m', 'main <file>', 'define entry point for the components'], ['n', 'namespace <namespace>', 'organize component in a namespace'], ['o', 'override <boolean>', 'override existing component if exists (default = false)'], ['s', 'scope <string>', `sets the component's scope-name. if not entered, the default-scope will be used`]]);
+    (0, _defineProperty2().default)(this, "loader", true);
+    (0, _defineProperty2().default)(this, "migration", true);
+  }
+  async report([paths = []], {
+    id,
+    main,
+    namespace,
+    scope,
+    override = false
+  }) {
+    if (namespace && id) {
+      throw new (_bitError().BitError)('please use either [id] or [namespace] to add a particular component');
+    }
+    const normalizedPaths = paths.map(p => path().normalize(p));
+    const {
+      addedComponents,
+      warnings
+    } = await this.tracker.addForCLI({
+      componentPaths: normalizedPaths,
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      id,
+      main: main ? path().normalize(main) : undefined,
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      namespace,
+      defaultScope: scope,
+      override
+    });
+    const paintWarning = () => {
+      const alreadyUsedOutput = () => {
+        const alreadyUsedWarning = Object.keys(warnings.alreadyUsed).map(key => _chalk().default.yellow(`warning: files ${_chalk().default.bold(warnings.alreadyUsed[key].join(', '))} already used by component: ${key}`)).filter(x => x).join('\n');
+        return _ramda().default.isEmpty(alreadyUsedWarning) ? '' : `${alreadyUsedWarning}\n`;
+      };
+      const emptyDirectoryOutput = () => {
+        if (!warnings.emptyDirectory.length) return '';
+        return _chalk().default.yellow(`warning: the following directories are empty or all their files were excluded\n${_chalk().default.bold(warnings.emptyDirectory.join('\n'))}\n`);
+      };
+      return alreadyUsedOutput() + emptyDirectoryOutput();
+    };
+    if (addedComponents.length > 1) {
+      return paintWarning() + _chalk().default.green(`tracking ${addedComponents.length} new components`);
+    }
+    return paintWarning() + _ramda().default.flatten(addedComponents.map(result => {
+      if (result.files.length === 0) {
+        return _chalk().default.underline.red(`could not track component ${_chalk().default.bold(result.id.toString())}: no files to track`);
+      }
+      const title = _chalk().default.underline(`tracking component ${_chalk().default.bold(result.id.toString())}:\n`);
+      const files = result.files.map(file => _chalk().default.green(`added ${file.relativePath}`));
+      return title + files.join('\n');
+    })).join('\n\n');
+  }
+}
+exports.AddCmd = AddCmd;
+
+//# sourceMappingURL=add-cmd.js.map

package/dist/add-cmd.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AddCmd","constructor","tracker","report","paths","id","main","namespace","scope","override","BitError","normalizedPaths","map","p","path","normalize","addedComponents","warnings","addForCLI","componentPaths","undefined","defaultScope","paintWarning","alreadyUsedOutput","alreadyUsedWarning","Object","keys","alreadyUsed","key","chalk","yellow","bold","join","filter","x","R","isEmpty","emptyDirectoryOutput","emptyDirectory","length","green","flatten","result","files","underline","red","toString","title","file","relativePath"],"sources":["add-cmd.ts"],"sourcesContent":["import { Command, CommandOptions } from '@teambit/cli';\nimport chalk from 'chalk';\nimport * as path from 'path';\nimport { BitError } from '@teambit/bit-error';\nimport { PathOsBased } from '@teambit/legacy/dist/utils/path';\nimport R from 'ramda';\nimport { AddActionResults, AddResult } from './add-components';\nimport { TrackerMain } from './tracker.main.runtime';\n\nexport class AddCmd implements Command {\n  name = 'add [path...]';\n  description = 'Add any subset of files to be tracked as a component(s).';\n  group = 'development';\n  extendedDescription = 'Learn the recommended workflow for tracking directories as components, in the link below.';\n  helpUrl = 'docs/workspace/creating-workspaces?new_existing_project=1';\n  alias = 'a';\n  options = [\n    ['i', 'id <name>', 'manually set component id'],\n    ['m', 'main <file>', 'define entry point for the components'],\n    ['n', 'namespace <namespace>', 'organize component in a namespace'],\n    ['o', 'override <boolean>', 'override existing component if exists (default = false)'],\n    ['s', 'scope <string>', `sets the component's scope-name. if not entered, the default-scope will be used`],\n  ] as CommandOptions;\n  loader = true;\n  migration = true;\n\n  constructor(private tracker: TrackerMain) {}\n\n  async report(\n    [paths = []]: [string[]],\n    {\n      id,\n      main,\n      namespace,\n      scope,\n      override = false,\n    }: {\n      id: string | null | undefined;\n      main: string | null | undefined;\n      namespace: string | null | undefined;\n      scope?: string;\n      override: boolean;\n    }\n  ) {\n    if (namespace && id) {\n      throw new BitError('please use either [id] or [namespace] to add a particular component');\n    }\n\n    const normalizedPaths: PathOsBased[] = paths.map((p) => path.normalize(p));\n    const { addedComponents, warnings }: AddActionResults = await this.tracker.addForCLI({\n      componentPaths: normalizedPaths,\n      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n      id,\n      main: main ? path.normalize(main) : undefined,\n      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n      namespace,\n      defaultScope: scope,\n      override,\n    });\n\n    const paintWarning = () => {\n      const alreadyUsedOutput = () => {\n        const alreadyUsedWarning = Object.keys(warnings.alreadyUsed)\n          .map((key) =>\n            chalk.yellow(\n              `warning: files ${chalk.bold(warnings.alreadyUsed[key].join(', '))} already used by component: ${key}`\n            )\n          )\n          .filter((x) => x)\n          .join('\\n');\n        return R.isEmpty(alreadyUsedWarning) ? '' : `${alreadyUsedWarning}\\n`;\n      };\n      const emptyDirectoryOutput = () => {\n        if (!warnings.emptyDirectory.length) return '';\n        return chalk.yellow(\n          `warning: the following directories are empty or all their files were excluded\\n${chalk.bold(\n            warnings.emptyDirectory.join('\\n')\n          )}\\n`\n        );\n      };\n      return alreadyUsedOutput() + emptyDirectoryOutput();\n    };\n\n    if (addedComponents.length > 1) {\n      return paintWarning() + chalk.green(`tracking ${addedComponents.length} new components`);\n    }\n\n    return (\n      paintWarning() +\n      R.flatten(\n        addedComponents.map((result: AddResult) => {\n          if (result.files.length === 0) {\n            return chalk.underline.red(\n              `could not track component ${chalk.bold(result.id.toString())}: no files to track`\n            );\n          }\n          const title = chalk.underline(`tracking component ${chalk.bold(result.id.toString())}:\\n`);\n          const files = result.files.map((file) => chalk.green(`added ${file.relativePath}`));\n          return title + files.join('\\n');\n        })\n      ).join('\\n\\n')\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/add-components.d.ts

@@ -0,0 +1,151 @@
+import { BitId } from '@teambit/legacy/dist/bit-id';
+import { BitIdStr } from '@teambit/legacy/dist/bit-id/bit-id';
+import BitMap from '@teambit/legacy/dist/consumer/bit-map';
+import Consumer from '@teambit/legacy/dist/consumer/consumer';
+import { ModelComponent } from '@teambit/legacy/dist/scope/models';
+import { PathLinux, PathOsBased } from '@teambit/legacy/dist/utils/path';
+import ComponentMap, { ComponentMapFile, Config } from '@teambit/legacy/dist/consumer/bit-map/component-map';
+export declare type AddResult = {
+    id: BitId;
+    files: ComponentMapFile[];
+};
+export declare type Warnings = {
+    alreadyUsed: Record<string, any>;
+    emptyDirectory: string[];
+    existInScope: BitId[];
+};
+export declare type AddActionResults = {
+    addedComponents: AddResult[];
+    warnings: Warnings;
+};
+export declare type PathOrDSL = PathOsBased | string;
+declare type PathsStats = {};
+export declare type AddedComponent = {
+    componentId: BitId;
+    files: ComponentMapFile[];
+    mainFile?: PathOsBased | null | undefined;
+    trackDir?: PathOsBased;
+    idFromPath: {
+        name: string;
+        namespace: string;
+    } | null | undefined;
+    immediateDir?: string;
+};
+export declare type AddProps = {
+    componentPaths: PathOsBased[];
+    id?: string;
+    main?: PathOsBased;
+    namespace?: string;
+    override: boolean;
+    trackDirFeature?: boolean;
+    defaultScope?: string;
+    config?: Config;
+    shouldHandleOutOfSync?: boolean;
+};
+export declare type AddContext = {
+    consumer: Consumer;
+    alternateCwd?: string;
+};
+export default class AddComponents {
+    consumer: Consumer;
+    bitMap: BitMap;
+    componentPaths: PathOsBased[];
+    id: string | null | undefined;
+    main: PathOsBased | null | undefined;
+    namespace: string | null | undefined;
+    override: boolean;
+    trackDirFeature: boolean | null | undefined;
+    warnings: Warnings;
+    ignoreList: string[];
+    gitIgnore: any;
+    alternateCwd: string | null | undefined;
+    addedComponents: AddResult[];
+    defaultScope?: string;
+    config?: Config;
+    shouldHandleOutOfSync?: boolean;
+    constructor(context: AddContext, addProps: AddProps);
+    joinConsumerPathIfNeeded(paths: PathOrDSL[]): PathOrDSL[];
+    /**
+     * @param {string[]} files - array of file-paths from which it should search for the dsl patterns.
+     * @param {*} filesWithPotentialDsl - array of file-path which may have DSL patterns
+     *
+     * @returns array of file-paths from 'files' parameter that match the patterns from 'filesWithPotentialDsl' parameter
+     */
+    getFilesAccordingToDsl(files: PathLinux[], filesWithPotentialDsl: PathOrDSL[]): Promise<PathLinux[]>;
+    /**
+     * unsupported files, such as, binary files, don't have link-file. instead, they have a symlink
+     * inside the component dir, pointing to the dependency.
+     * this methods check whether a file is auto generated for the unsupported files.
+     */
+    _isGeneratedForUnsupportedFiles(fileRelativePath: PathLinux, componentId: BitId, componentMap: ComponentMap): Promise<boolean>;
+    /**
+     * for imported component, the package.json in the root directory is a bit-generated file and as
+     * such, it should be ignored
+     */
+    _isPackageJsonOnRootDir(pathRelativeToConsumerRoot: PathLinux, componentMap: ComponentMap): boolean;
+    /**
+     * imported components might have wrapDir, when they do, files should not be added outside of
+     * that wrapDir
+     */
+    _isOutsideOfWrapDir(pathRelativeToConsumerRoot: PathLinux, componentMap: ComponentMap): boolean;
+    /**
+     * Add or update existing (imported and new) component according to bitmap
+     * there are 3 options:
+     * 1. a user is adding a new component. there is no record for this component in bit.map
+     * 2. a user is updating an existing component. there is a record for this component in bit.map
+     * 3. some or all the files of this component were previously added as another component-id.
+     */
+    addOrUpdateComponentInBitMap(component: AddedComponent): Promise<AddResult | null | undefined>;
+    /**
+     * current componentFiles are relative to the workspace. we want them relative to the rootDir.
+     */
+    _updateFilesAccordingToExistingRootDir(foundComponentFromBitMap: ComponentMap, componentFiles: ComponentMapFile[], component: AddedComponent): void;
+    /**
+     * the risk with merging the currently added files with the existing bitMap files is overriding
+     * the `test` property. e.g. the component directory is re-added without adding the tests flag to
+     * track new files in that directory. in this case, we want to preserve the `test` property.
+     */
+    _mergeFilesWithExistingComponentMapFiles(componentFiles: ComponentMapFile[], existingComponentMapFile: ComponentMapFile[]): any;
+    /**
+     * if an existing file is for example uppercase and the new file is lowercase it has different
+     * behavior according to the OS. some OS are case sensitive, some are not.
+     * it's safer to avoid saving both files and instead, replacing the old file with the new one.
+     * in case a file has replaced and it is also a mainFile, replace the mainFile as well
+     */
+    _updateFilesWithCurrentLetterCases(currentComponentMap: ComponentMap, newFiles: ComponentMapFile[]): void;
+    _getComponentFromScopeIfExist(id: BitId): Promise<ModelComponent | null | undefined>;
+    /**
+     * if the id is already saved in bitmap file, it might have more data (such as scope, version)
+     * use that id instead.
+     */
+    _getIdAccordingToExistingComponent(currentId: BitIdStr): BitId;
+    _getIdAccordingToTrackDir(dir: PathOsBased): BitId | null | undefined;
+    /**
+     * used for updating main file if exists or doesn't exists
+     */
+    _addMainFileToFiles(files: ComponentMapFile[]): PathOsBased | null | undefined;
+    _findMainFileInFiles(mainFile: string, files: ComponentMapFile[]): ComponentMapFile | undefined;
+    /**
+     * given the component paths, prepare the id, mainFile and files to be added later on to bitmap
+     * the id of the component is either entered by the user or, if not entered, concluded by the path.
+     * e.g. bar/foo.js, the id would be bar/foo.
+     * in case bitmap has already the same id, the complete id is taken from bitmap (see _getIdAccordingToExistingComponent)
+     */
+    addOneComponent(componentPathsStats: PathsStats): Promise<AddedComponent>;
+    getIgnoreList(): string[];
+    add(): Promise<AddActionResults>;
+    linkComponents(ids: BitId[]): Promise<void>;
+    addMultipleComponents(componentPathsStats: PathsStats): Promise<void>;
+    /**
+     * some uses of wildcards might add directories and their files at the same time, in such cases
+     * only the files are needed and the directories can be ignored.
+     * @see https://github.com/teambit/bit/issues/1406 for more details
+     */
+    _removeDirectoriesWhenTheirFilesAreAdded(componentPathsStats: PathsStats): void;
+    _addMultipleToBitMap(added: AddedComponent[]): Promise<void>;
+    _removeNamespaceIfNotNeeded(addedComponents: AddedComponent[]): void;
+    _tryAddingMultiple(componentPathsStats: PathsStats): Promise<AddedComponent[]>;
+    _throwForOutsideConsumer(relativeToConsumerPath: PathOsBased): void;
+    private throwForExistingParentDir;
+}
+export {};