@teambit/objects 0.0.19

package/objects/scope-index.spec.ts

@@ -0,0 +1,95 @@
+import { expect } from 'chai';
+
+import { ModelComponent } from '../models';
+import { ScopeIndex } from './scope-index';
+import BitObject from './object';
+
+describe('ComponentsIndex', () => {
+  describe('addOne', () => {
+    let scopeIndex: ScopeIndex;
+    beforeEach(() => {
+      scopeIndex = new ScopeIndex('scope-path');
+    });
+    it('should add to the index array', () => {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      const modelComponent = new ModelComponent({ scope: 'my-scope', name: 'is-string' });
+      scopeIndex.addOne(modelComponent);
+      const allItems = scopeIndex.getAll();
+      // @ts-ignore
+      expect(allItems[0].id).to.deep.equal({ scope: 'my-scope', name: 'is-string' });
+    });
+    it('should not add the same component multiple times', () => {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      const modelComponent = new ModelComponent({ scope: 'my-scope', name: 'is-string' });
+      scopeIndex.addOne(modelComponent);
+      scopeIndex.addOne(modelComponent);
+      scopeIndex.addOne(modelComponent);
+      expect(scopeIndex.getAll()).to.have.lengthOf(1);
+    });
+    it('should not add BitObjects that are not Symlink nor ModelComponent', () => {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      const bitObject = new BitObject({ scope: 'my-scope', name: 'is-string' });
+      const result = scopeIndex.addOne(bitObject);
+      expect(scopeIndex.getAll()).to.have.lengthOf(0);
+      expect(result).to.be.false;
+    });
+  });
+  describe('remove', () => {
+    let scopeIndex: ScopeIndex;
+    beforeEach(() => {
+      scopeIndex = new ScopeIndex('scope-path');
+    });
+    it('should remove from the index array', () => {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      const modelComponent = new ModelComponent({ scope: 'my-scope', name: 'is-string' });
+      scopeIndex.addOne(modelComponent);
+      expect(scopeIndex.getAll()).to.have.lengthOf(1);
+      scopeIndex.removeOne(modelComponent.hash().toString());
+      expect(scopeIndex.getAll()).to.have.lengthOf(0);
+    });
+    it('should remove the correct one when there are multiple', () => {
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      const isStringComponent = new ModelComponent({ scope: 'my-scope', name: 'is-string' });
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      const isTypeComponent = new ModelComponent({ scope: 'my-scope', name: 'is-type' });
+      scopeIndex.addOne(isStringComponent);
+      scopeIndex.addOne(isTypeComponent);
+      expect(scopeIndex.getAll()).to.have.lengthOf(2);
+      scopeIndex.removeOne(isStringComponent.hash().toString());
+      const allIds = scopeIndex.getAll();
+      expect(allIds).to.have.lengthOf(1);
+      // @ts-ignore
+      expect(allIds[0].id).to.deep.equal({ scope: 'my-scope', name: 'is-type' });
+    });
+  });
+  describe('removeMany', () => {
+    let scopeIndex: ScopeIndex;
+    let isStringComponent;
+    let isTypeComponent;
+    beforeEach(() => {
+      scopeIndex = new ScopeIndex('scope-path');
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      isStringComponent = new ModelComponent({ scope: 'my-scope', name: 'is-string' });
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      isTypeComponent = new ModelComponent({ scope: 'my-scope', name: 'is-type' });
+      scopeIndex.addMany([isStringComponent, isTypeComponent]);
+      expect(scopeIndex.getAll()).to.have.lengthOf(2);
+    });
+    it('should remove multiple when removing them at the same removeMany call', () => {
+      expect(scopeIndex.getAll()).to.have.lengthOf(2);
+      scopeIndex.removeMany([isStringComponent.hash().toString(), isTypeComponent.hash().toString()]);
+      expect(scopeIndex.getAll()).to.have.lengthOf(0);
+    });
+    it('should remove multiple when removing them with separate removeMany calls', () => {
+      expect(scopeIndex.getAll()).to.have.lengthOf(2);
+      scopeIndex.removeMany([isStringComponent.hash().toString()]);
+      scopeIndex.removeMany([isTypeComponent.hash().toString()]);
+      expect(scopeIndex.getAll()).to.have.lengthOf(0);
+    });
+    it('should remove multiple when calling them with separate removeMany calls using array.map', () => {
+      expect(scopeIndex.getAll()).to.have.lengthOf(2);
+      [isStringComponent.hash().toString(), isTypeComponent.hash().toString()].map((h) => scopeIndex.removeMany([h]));
+      expect(scopeIndex.getAll()).to.have.lengthOf(0);
+    });
+  });
+});

package/objects/scope-index.ts

@@ -0,0 +1,192 @@
+/* eslint max-classes-per-file: 0 */
+import fs from 'fs-extra';
+import { Mutex } from 'async-mutex';
+import * as path from 'path';
+import { LaneId } from '@teambit/lane-id';
+import { logger } from '@teambit/legacy.logger';
+import { InvalidIndexJson } from '@teambit/legacy.scope';
+import { ModelComponent, Symlink } from '../models';
+import Lane from '../models/lane';
+import BitObject from './object';
+import Ref from './ref';
+import { difference } from 'lodash';
+
+const COMPONENTS_INDEX_FILENAME = 'index.json';
+
+export interface IndexItem {
+  hash: string;
+  toIdentifierString(): string;
+}
+
+export class ComponentItem implements IndexItem {
+  constructor(
+    public id: { scope: string | null; name: string },
+    public isSymlink: boolean,
+    public hash: string
+  ) {}
+
+  toIdentifierString(): string {
+    const scope = this.id.scope ? `${this.id.scope}/` : '';
+    return `component "${scope}${this.id.name}"`;
+  }
+}
+
+export class LaneItem implements IndexItem {
+  constructor(
+    public id: { scope: string; name: string },
+    public hash: string
+  ) {}
+
+  toIdentifierString() {
+    const scope = this.id.scope ? `${this.id.scope}/` : '';
+    return `lane "${scope}${this.id.name}"`;
+  }
+
+  toLaneId(): LaneId {
+    return new LaneId({ name: this.id.name, scope: this.id.scope });
+  }
+}
+
+export enum IndexType {
+  components = 'components',
+  lanes = 'lanes',
+}
+
+type Index = { [IndexType.components]: ComponentItem[]; [IndexType.lanes]: LaneItem[] };
+
+export class ScopeIndex {
+  indexPath: string;
+  index: Index;
+  writeIndexMutex = new Mutex();
+  constructor(indexPath: string, index: Index = { [IndexType.components]: [], [IndexType.lanes]: [] }) {
+    this.indexPath = indexPath;
+    this.index = index;
+  }
+  static async load(basePath: string): Promise<ScopeIndex> {
+    const indexPath = this._composePath(basePath);
+    try {
+      const indexRaw = await fs.readJson(indexPath);
+      const getIndexWithBackwardCompatibility = (): Index => {
+        if (Array.isArray(indexRaw)) {
+          return { [IndexType.components]: indexRaw, [IndexType.lanes]: [] };
+        }
+        return indexRaw;
+      };
+      const indexObject = getIndexWithBackwardCompatibility();
+      const index = {
+        [IndexType.components]: indexObject[IndexType.components].map(
+          (c) => new ComponentItem(c.id, c.isSymlink, c.hash)
+        ),
+        [IndexType.lanes]: indexObject[IndexType.lanes].map((l) => new LaneItem(l.id, l.hash)),
+      };
+      return new ScopeIndex(indexPath, index);
+    } catch (err: any) {
+      if (err.message.includes('Unexpected token')) {
+        throw new InvalidIndexJson(indexPath, err.message);
+      }
+      throw err;
+    }
+  }
+  static create(basePath: string): ScopeIndex {
+    const indexPath = this._composePath(basePath);
+    return new ScopeIndex(indexPath);
+  }
+  static async reset(basePath: string) {
+    const indexPath = this._composePath(basePath);
+    logger.debug(`ComponentsIndex, deleting the index file at ${indexPath}`);
+    await fs.remove(indexPath);
+  }
+  async write() {
+    // write only one at a time to avoid corrupting the json file.
+    await this.writeIndexMutex.runExclusive(() => fs.writeJson(this.indexPath, this.index, { spaces: 2 }));
+  }
+  getAll(): IndexItem[] {
+    return Object.values(this.index).flat();
+  }
+
+  getHashes(indexType: IndexType): string[] {
+    // @ts-ignore how to tell TS that all this.index.prop are array?
+    return this.index[indexType].map((indexItem: IndexItem) => indexItem.hash);
+  }
+  getHashesByQuery(indexType: IndexType, filter: Function): string[] {
+    // @ts-ignore how to tell TS that all this.index.prop are array?
+    return this.index[indexType].filter(filter).map((indexItem: IndexItem) => indexItem.hash);
+  }
+  getHashesIncludeSymlinks(): string[] {
+    return this.index.components.map((indexItem) => indexItem.hash);
+  }
+  addMany(bitObjects: BitObject[]): boolean {
+    const added = bitObjects.map((bitObject) => this.addOne(bitObject));
+    return added.some((oneAdded) => oneAdded); // return true if one of the objects was added
+  }
+  addOne(bitObject: BitObject): boolean {
+    if (!(bitObject instanceof ModelComponent) && !(bitObject instanceof Symlink) && !(bitObject instanceof Lane))
+      return false;
+    const hash = bitObject.hash().toString();
+
+    if (bitObject instanceof Lane) {
+      const found = this.find(hash) as LaneItem | undefined;
+      if (found) {
+        if ((found as LaneItem).toLaneId().isEqual(bitObject.toLaneId())) return false;
+        found.id = bitObject.toLaneId();
+      } else {
+        const laneItem = new LaneItem(bitObject.toLaneId(), hash);
+        this.index.lanes.push(laneItem);
+      }
+      return true;
+    }
+    if (bitObject instanceof ModelComponent || bitObject instanceof Symlink) {
+      if (this._exist(hash)) return false;
+      const componentItem = new ComponentItem(
+        { scope: bitObject.scope || null, name: bitObject.name },
+        bitObject instanceof Symlink,
+        hash
+      );
+      this.index.components.push(componentItem);
+    }
+    return true;
+  }
+  removeMany(refs: Ref[]): boolean {
+    const removed = refs.map((ref) => this.removeOne(ref.toString()));
+    return removed.some((removedOne) => removedOne); // return true if one of the objects was removed
+  }
+  removeOne(hash: string): boolean {
+    for (const entity of Object.keys(IndexType)) {
+      const found = this.index[entity].find((indexItem) => indexItem.hash === hash);
+      if (found) {
+        this.index[entity] = difference(this.index[entity], [found]);
+        return true;
+      }
+    }
+    return false;
+  }
+  async deleteFile() {
+    logger.debug(`ComponentsIndex, deleting the index file at ${this.indexPath}`);
+    await fs.remove(this.indexPath);
+  }
+  getPath() {
+    return this.indexPath;
+  }
+  /**
+   * it's obviously not accurate. a local path might include 'bithub' as part of the path as well.
+   * however, it's needed only for suppressing the error message when the indexJson is outdate,
+   * so if it happens on a local scope it's okay.
+   * for other purposes, don't rely on this.
+   */
+  isFileOnBitHub() {
+    return this.indexPath.includes('/bithub/') || this.indexPath.includes('/tmp/scope-fs/');
+  }
+  find(hash: string): IndexItem | null {
+    for (const entity of Object.keys(IndexType)) {
+      const found = this.index[entity].find((indexItem) => indexItem.hash === hash);
+      if (found) return found;
+    }
+    return null;
+  }
+  _exist(hash: string): boolean {
+    return Boolean(this.find(hash));
+  }
+  static _composePath(basePath: string): string {
+    return path.join(basePath, COMPONENTS_INDEX_FILENAME);
+  }
+}

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@teambit/objects",
+  "version": "0.0.19",
+  "homepage": "https://bit.cloud/teambit/scope/objects",
+  "main": "dist/index.js",
+  "componentId": {
+    "scope": "teambit.scope",
+    "name": "objects",
+    "version": "0.0.19"
+  },
+  "dependencies": {
+    "lodash": "4.17.21",
+    "tar-stream": "2.2.0",
+    "p-map-series": "2.1.0",
+    "is-relative-path": "2.0.0",
+    "async-mutex": "0.3.1",
+    "fs-extra": "10.0.0",
+    "uid-number": "0.0.6",
+    "@pnpm/dependency-path": "900.0.0",
+    "@pnpm/lockfile.types": "^900.0.0",
+    "semver": "7.5.4",
+    "uuid": "8.3.2",
+    "@teambit/harmony": "0.4.6",
+    "@teambit/component-id": "1.2.2",
+    "@teambit/graph.cleargraph": "0.0.11",
+    "@teambit/bit-error": "0.0.404",
+    "@teambit/component-version": "1.0.3",
+    "@teambit/lane-id": "0.0.312",
+    "@teambit/legacy-bit-id": "1.1.1",
+    "@teambit/cli": "0.0.1089",
+    "@teambit/component.snap-distance": "0.0.20",
+    "@teambit/graph": "1.0.512",
+    "@teambit/harmony.modules.concurrency": "0.0.6",
+    "@teambit/legacy.logger": "0.0.7",
+    "@teambit/legacy.scope": "0.0.19",
+    "@teambit/toolbox.promise.map-pool": "0.0.3",
+    "@teambit/legacy.constants": "0.0.5",
+    "@teambit/legacy.utils": "0.0.13",
+    "@teambit/toolbox.crypto.sha1": "0.0.5",
+    "@teambit/harmony.modules.in-memory-cache": "0.0.7",
+    "@teambit/toolbox.fs.remove-empty-dir": "0.0.3",
+    "@teambit/harmony.modules.get-basic-log": "0.0.20",
+    "@teambit/legacy.cli.error": "0.0.7",
+    "@teambit/legacy.global-config": "0.0.5",
+    "@teambit/component.sources": "0.0.71",
+    "@teambit/harmony.modules.feature-toggle": "0.0.13",
+    "@teambit/legacy-component-log": "0.0.405",
+    "@teambit/legacy.consumer-component": "0.0.20",
+    "@teambit/legacy.consumer-config": "0.0.19",
+    "@teambit/legacy.extension-data": "0.0.21",
+    "@teambit/pkg.modules.semver-helper": "0.0.4",
+    "@teambit/toolbox.array.duplications-finder": "0.0.3",
+    "@teambit/bit.get-bit-version": "0.0.3",
+    "@teambit/semantics.doc-parser": "0.0.27"
+  },
+  "devDependencies": {
+    "@types/lodash": "4.14.165",
+    "@types/fs-extra": "9.0.7",
+    "chai": "4.3.0",
+    "@types/semver": "7.3.4",
+    "@types/uuid": "8.3.4",
+    "@teambit/harmony.envs.core-aspect-env": "0.0.65"
+  },
+  "peerDependencies": {
+    "@types/chai": "4.3.19"
+  },
+  "license": "Apache-2.0",
+  "optionalDependencies": {},
+  "peerDependenciesMeta": {},
+  "exports": {
+    ".": {
+      "node": {
+        "require": "./dist/index.js",
+        "import": "./dist/esm.mjs"
+      },
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./artifacts/*": "./artifacts/*",
+    "./*": "./*.ts"
+  },
+  "private": false,
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teambit/bit"
+  },
+  "keywords": [
+    "bit",
+    "bit-aspect",
+    "bit-core-aspect",
+    "components",
+    "collaboration",
+    "web"
+  ]
+}

package/types/asset.d.ts

@@ -0,0 +1,41 @@
+declare module '*.png' {
+  const value: any;
+  export = value;
+}
+declare module '*.svg' {
+  import type { FunctionComponent, SVGProps } from 'react';
+
+  export const ReactComponent: FunctionComponent<
+    SVGProps<SVGSVGElement> & { title?: string }
+  >;
+  const src: string;
+  export default src;
+}
+declare module '*.jpg' {
+  const value: any;
+  export = value;
+}
+declare module '*.jpeg' {
+  const value: any;
+  export = value;
+}
+declare module '*.gif' {
+  const value: any;
+  export = value;
+}
+declare module '*.bmp' {
+  const value: any;
+  export = value;
+}
+declare module '*.otf' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff2' {
+  const value: any;
+  export = value;
+}

package/types/style.d.ts

@@ -0,0 +1,42 @@
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.mdx' {
+  const component: any;
+  export default component;
+}