@teambit/scope 1.0.228 → 1.0.230

package/dist/clear-cache-action.d.ts

@@ -0,0 +1,7 @@
+import { ScopeMain } from './scope.main.runtime';
+export declare class ClearCacheAction {
+    private scope;
+    name: string;
+    constructor(scope: ScopeMain);
+    execute(): Promise<boolean>;
+}

package/dist/exceptions/component-not-found.d.ts

@@ -0,0 +1,9 @@
+import { BitError } from '@teambit/bit-error';
+import { ComponentID } from '@teambit/component';
+export declare class ComponentNotFound extends BitError {
+    constructor(
+    /**
+     * id of the missing component.
+     */
+    id: ComponentID);
+}

package/dist/exceptions/index.d.ts

@@ -0,0 +1,2 @@
+export { ComponentNotFound } from './component-not-found';
+export { NoIdMatchPattern } from './no-id-match-pattern';

package/dist/exceptions/no-id-match-pattern.d.ts

@@ -0,0 +1,4 @@
+import { BitError } from '@teambit/bit-error';
+export declare class NoIdMatchPattern extends BitError {
+    constructor(pattern: string);
+}

package/dist/get-scope-options.d.ts

@@ -0,0 +1,19 @@
+import { DrawerType } from '@teambit/ui-foundation.ui.tree.drawer';
+import { ComponentType, ReactNode } from 'react';
+import { ComponentUrlResolver } from '@teambit/component.modules.component-url';
+import type { ScopeModel } from '@teambit/scope.models.scope-model';
+export type GetScopeOptions = {
+    useScope?: () => {
+        scope: ScopeModel | undefined;
+    };
+    Corner?: ComponentType;
+    paneClassName?: string;
+    scopeClassName?: string;
+    TargetScopeOverview?: ComponentType;
+    PaneWrapper?: ComponentType<{
+        children: ReactNode;
+    }>;
+    overrideDrawers?: DrawerType[];
+    onSidebarToggle?: (callback: () => void) => void;
+    getComponentUrl?: ComponentUrlResolver;
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { ScopeAspect } from './scope.aspect';
+export { ComponentNotFound, NoIdMatchPattern } from './exceptions';
+export { ScopeComponentCard } from './ui/scope-overview/scope-overview';
+export type { ScopeMain } from './scope.main.runtime';
+export type { ScopeModel } from '@teambit/scope.models.scope-model';
+export { ScopeContext } from '@teambit/scope.ui.hooks.scope-context';
+export type { StagedConfig } from './staged-config';
+export type { ScopeUI, ScopeBadgeSlot, ScopeOverview, ScopeOverviewSlot, OverviewLineSlot } from './scope.ui.runtime';
+export { ScopeAspect };
+export default ScopeAspect;

package/dist/{preview-1712805335812.js → preview-1712891953391.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.scope_scope@1.0.228/dist/scope.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.scope_scope@1.0.228/dist/scope.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.scope_scope@1.0.230/dist/scope.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.scope_scope@1.0.230/dist/scope.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/dist/routes/action.route.d.ts

@@ -0,0 +1,10 @@
+import { Route, Verb, Request, Response } from '@teambit/express';
+import { ScopeMain } from '../scope.main.runtime';
+export declare class ActionRoute implements Route {
+    private scope;
+    constructor(scope: ScopeMain);
+    method: string;
+    route: string;
+    verb: Verb;
+    middlewares: ((req: Request, res: Response) => Promise<void>)[];
+}

package/dist/routes/delete.route.d.ts

@@ -0,0 +1,10 @@
+import { Route, Verb, Request, Response } from '@teambit/express';
+import { ScopeMain } from '../scope.main.runtime';
+export declare class DeleteRoute implements Route {
+    private scope;
+    constructor(scope: ScopeMain);
+    method: string;
+    route: string;
+    verb: Verb;
+    middlewares: ((req: Request, res: Response) => Promise<void>)[];
+}

package/dist/routes/fetch.route.d.ts

@@ -0,0 +1,12 @@
+import { Route, Verb, Request, Response } from '@teambit/express';
+import { Logger } from '@teambit/logger';
+import { ScopeMain } from '../scope.main.runtime';
+export declare class FetchRoute implements Route {
+    private scope;
+    private logger;
+    constructor(scope: ScopeMain, logger: Logger);
+    route: string;
+    method: string;
+    verb: Verb;
+    middlewares: ((req: Request, res: Response) => Promise<void>)[];
+}

package/dist/routes/index.d.ts

@@ -0,0 +1,4 @@
+export { FetchRoute } from './fetch.route';
+export { PutRoute } from './put.route';
+export { ActionRoute } from './action.route';
+export { DeleteRoute } from './delete.route';

package/dist/routes/put.route.d.ts

@@ -0,0 +1,11 @@
+import { Route, Verb, Request, Response } from '@teambit/express';
+import { OnPostPutSlot, ScopeMain } from '../scope.main.runtime';
+export declare class PutRoute implements Route {
+    private scope;
+    private postPutSlot;
+    constructor(scope: ScopeMain, postPutSlot: OnPostPutSlot);
+    method: string;
+    route: string;
+    verb: Verb;
+    middlewares: ((req: Request, res: Response) => Promise<void>)[];
+}

package/dist/scope-aspects-loader.d.ts

@@ -0,0 +1,91 @@
+import { GlobalConfigMain } from '@teambit/global-config';
+import { Lane } from '@teambit/legacy/dist/scope/models';
+import { IsolateComponentsOptions, IsolatorMain } from '@teambit/isolator';
+import { AspectLoaderMain, AspectDefinition } from '@teambit/aspect-loader';
+import { RequireableComponent } from '@teambit/harmony.modules.requireable-component';
+import { ExtensionManifest, Aspect } from '@teambit/harmony';
+import { Component, ComponentID, LoadAspectsOptions, ResolveAspectsOptions } from '@teambit/component';
+import { Logger } from '@teambit/logger';
+import { EnvsMain } from '@teambit/envs';
+import { NodeLinker } from '@teambit/dependency-resolver';
+import { ScopeMain } from './scope.main.runtime';
+type ManifestOrAspect = ExtensionManifest | Aspect;
+export type ScopeLoadAspectsOptions = LoadAspectsOptions & {
+    useScopeAspectsCapsule?: boolean;
+    packageManagerConfigRootDir?: string;
+    workspaceName?: string;
+};
+export declare class ScopeAspectsLoader {
+    private scope;
+    private aspectLoader;
+    private envs;
+    private isolator;
+    private logger;
+    private globalConfig;
+    constructor(scope: ScopeMain, aspectLoader: AspectLoaderMain, envs: EnvsMain, isolator: IsolatorMain, logger: Logger, globalConfig: GlobalConfigMain);
+    loadAspects(ids: string[], throwOnError?: boolean, neededFor?: string, lane?: Lane, opts?: ScopeLoadAspectsOptions): Promise<string[]>;
+    /**
+     * This function get's a list of aspect ids and return them grouped by whether any of them is the env of other from the list
+     * @param ids
+     */
+    groupAspectIdsByEnvOfTheList(ids: string[], lane?: Lane): Promise<{
+        envs?: string[];
+        other?: string[];
+    }>;
+    private getManifestsAndLoadAspects;
+    getManifestsGraphRecursively(ids: string[], visited?: string[], throwOnError?: boolean, lane?: Lane, opts?: {
+        packageManagerConfigRootDir?: string;
+        workspaceName?: string;
+    }): Promise<{
+        manifests: ManifestOrAspect[];
+        potentialPluginsIds: string[];
+    }>;
+    private getNonLoadedAspects;
+    getResolvedAspects(components: Component[], opts?: {
+        skipIfExists?: boolean;
+        packageManagerConfigRootDir?: string;
+        workspaceName?: string;
+    }): Promise<RequireableComponent[]>;
+    private compileIfNoDist;
+    private tryCompile;
+    requireAspects(components: Component[], throwOnError?: boolean, opts?: {
+        packageManagerConfigRootDir?: string;
+        workspaceName?: string;
+    }): Promise<Array<ExtensionManifest | Aspect>>;
+    shouldUseDatedCapsules(): boolean;
+    shouldCacheLockFileOnly(): boolean;
+    getAspectCapsulePath(): string;
+    shouldUseHashForCapsules(): boolean;
+    getAspectsPackageManager(): string | undefined;
+    getAspectsNodeLinker(): NodeLinker | undefined;
+    private resolveUserAspects;
+    resolveAspects(runtimeName?: string, componentIds?: ComponentID[], opts?: ResolveAspectsOptions): Promise<AspectDefinition[]>;
+    getIsolateOpts(opts?: {
+        skipIfExists?: boolean;
+        packageManagerConfigRootDir?: string;
+        workspaceName?: string;
+    }): IsolateComponentsOptions;
+    getDefaultIsolateOpts(): {
+        datedDirId: string;
+        baseDir: string;
+        useHash: boolean;
+        packageManager: string | undefined;
+        nodeLinker: NodeLinker | undefined;
+        useDatedDirs: boolean;
+        cacheLockFileOnly: boolean;
+        skipIfExists: boolean;
+        seedersOnly: boolean;
+        includeFromNestedHosts: boolean;
+        host: ScopeMain;
+        installOptions: {
+            copyPeerToRuntimeOnRoot: boolean;
+            useNesting: boolean;
+            copyPeerToRuntimeOnComponents: boolean;
+            installPeersFromEnvs: boolean;
+        };
+        context: {
+            aspects: boolean;
+        };
+    };
+}
+export {};

package/dist/scope-cmd.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@teambit/cli';
+export declare class ScopeCmd implements Command {
+    name: string;
+    alias: string;
+    description: string;
+    options: never[];
+    group: string;
+    commands: Command[];
+    report([unrecognizedSubcommand]: [string]): Promise<string>;
+}

package/dist/scope-component-loader.d.ts

@@ -0,0 +1,36 @@
+import { Component, ComponentID, Snap, State } from '@teambit/component';
+import { Logger } from '@teambit/logger';
+import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
+import type { ScopeMain } from './scope.main.runtime';
+export declare class ScopeComponentLoader {
+    private scope;
+    private logger;
+    private componentsCache;
+    private importedComponentsCache;
+    constructor(scope: ScopeMain, logger: Logger);
+    get(id: ComponentID, importIfMissing?: boolean, useCache?: boolean): Promise<Component | undefined>;
+    getFromConsumerComponent(consumerComponent: ConsumerComponent): Promise<Component>;
+    /**
+     * get a component from a remote without importing it
+     */
+    getRemoteComponent(id: ComponentID): Promise<Component>;
+    /**
+     * get components from a remote without importing it
+     */
+    getManyRemoteComponents(ids: ComponentID[]): Promise<Component[]>;
+    getState(id: ComponentID, hash: string): Promise<State>;
+    getSnap(id: ComponentID, hash: string): Promise<Snap>;
+    clearCache(): void;
+    /**
+     * make sure that not only the id-str match, but also the legacy-id.
+     * this is needed because the ComponentID.toString() is the same whether or not the legacy-id has
+     * scope-name, as it includes the defaultScope if the scope is empty.
+     * as a result, when out-of-sync is happening and the id is changed to include scope-name in the
+     * legacy-id, the component is the cache has the old id.
+     */
+    private getFromCache;
+    private getTagMap;
+    private getHeadSnap;
+    private createSnapFromVersion;
+    private createStateFromVersion;
+}

package/dist/scope.aspect.d.ts

@@ -0,0 +1,3 @@
+import { Aspect } from '@teambit/harmony';
+export declare const ScopeAspect: Aspect;
+export default ScopeAspect;

package/dist/scope.composition.d.ts

@@ -0,0 +1 @@
+export declare const Logo: () => import("react/jsx-runtime").JSX.Element;

package/dist/scope.graphql.d.ts

@@ -0,0 +1,37 @@
+import { LegacyComponentLog as ComponentLog } from '@teambit/legacy-component-log';
+import { ScopeMain } from './scope.main.runtime';
+export declare function scopeSchema(scopeMain: ScopeMain): {
+    typeDefs: import("apollo-link").DocumentNode;
+    resolvers: {
+        Scope: {
+            name: (scope: ScopeMain) => string;
+            description: (scope: ScopeMain) => string | undefined;
+            icon: (scope: ScopeMain) => string | undefined;
+            backgroundIconColor: (scope: ScopeMain) => string | undefined;
+            components: (scope: ScopeMain, props?: {
+                offset: number;
+                limit: number;
+                includeCache?: boolean;
+                namespaces?: string[];
+            }) => Promise<import("@teambit/component").Component[]>;
+            get: (scope: ScopeMain, { id }: {
+                id: string;
+            }) => Promise<import("@teambit/component").Component | undefined>;
+            _getLegacy: (scope: ScopeMain, { id }: {
+                id: string;
+            }) => Promise<any>;
+            _legacyLatestVersions: (scope: ScopeMain, { ids }: {
+                ids: string[];
+            }) => Promise<string[]>;
+            getLogs: (scope: ScopeMain, { id }: {
+                id: string;
+            }) => Promise<ComponentLog[]>;
+            getMany: (scope: ScopeMain, { ids }: {
+                ids: string[];
+            }) => Promise<import("@teambit/component").Component[]>;
+        };
+        Query: {
+            scope: () => ScopeMain;
+        };
+    };
+};