cnpmcore 4.11.0 → 4.11.1

package/dist/app/port/controller/BinarySyncController.js

@@ -13,10 +13,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, HTTPQuery, Inject, Middleware, HTTPBody, } from '@eggjs/tegg';
 import path from 'node:path';
 import { NotFoundError } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import binaries, {} from '../../../config/binaries.js';
-import { BinaryNameRule, BinarySubpathRule } from '../typebox.js';
-import { AdminAccess } from '../middleware/AdminAccess.js';
+import { AbstractController } from "./AbstractController.js";
+import binaries, {} from "../../../config/binaries.js";
+import { BinaryNameRule, BinarySubpathRule } from "../typebox.js";
+import { AdminAccess } from "../middleware/AdminAccess.js";
 let BinarySyncController = class BinarySyncController extends AbstractController {
     async showBinaryHTML(ctx) {
         ctx.type = 'html';

package/dist/app/port/controller/ChangesStreamController.d.ts

@@ -1,5 +1,5 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from './AbstractController.js';
+import { AbstractController } from './AbstractController.ts';
 export declare class ChangesStreamController extends AbstractController {
     private changeRepository;
     listChanges(ctx: EggContext, since: string): Promise<{

package/dist/app/port/controller/ChangesStreamController.js

@@ -12,7 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPQuery, Inject, } from '@eggjs/tegg';
 import { Type } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from './AbstractController.js';
+import { AbstractController } from "./AbstractController.js";
 const ChangeRule = Type.Object({
     since: Type.Integer({ minimum: 0 }),
 });

package/dist/app/port/controller/DownloadController.d.ts

@@ -1,4 +1,4 @@
-import { AbstractController } from './AbstractController.js';
+import { AbstractController } from './AbstractController.ts';
 export declare class DownloadController extends AbstractController {
     private packageVersionDownloadRepository;
     showPackageDownloads(fullname: string, range: string): Promise<{

package/dist/app/port/controller/DownloadController.js

@@ -12,9 +12,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
 import { NotFoundError, UnprocessableEntityError } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import { FULLNAME_REG_STRING, getScopeAndName, } from '../../common/PackageUtil.js';
-import dayjs from '../../common/dayjs.js';
+import { AbstractController } from "./AbstractController.js";
+import { FULLNAME_REG_STRING, getScopeAndName, } from "../../common/PackageUtil.js";
+import dayjs from "../../common/dayjs.js";
 const DATE_FORMAT = 'YYYY-MM-DD';
 let DownloadController = class DownloadController extends AbstractController {
     async showPackageDownloads(fullname, range) {

package/dist/app/port/controller/HomeController.d.ts

@@ -1,6 +1,6 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from './AbstractController.js';
-import type { DownloadInfo, UpstreamRegistryInfo } from '../../core/service/CacheService.js';
+import { AbstractController } from './AbstractController.ts';
+import type { DownloadInfo, UpstreamRegistryInfo } from '../../core/service/CacheService.ts';
 type SiteTotalData = LegacyInfo & SiteEnvInfo & TotalInfo;
 interface LegacyInfo {
     source_registry: string;

package/dist/app/port/controller/HomeController.js

@@ -13,7 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { performance } from 'node:perf_hooks';
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, Inject, } from '@eggjs/tegg';
 import pkg from 'egg/package.json' with { type: 'json' };
-import { AbstractController } from './AbstractController.js';
+import { AbstractController } from "./AbstractController.js";
 const EggVersion = pkg.version;
 const startTime = new Date();
 let HomeController = class HomeController extends AbstractController {

package/dist/app/port/controller/HookController.d.ts

@@ -13,11 +13,11 @@ export declare class HookController {
     private readonly hookManageService;
     private readonly taskService;
     private readonly userRoleManager;
-    createHook(ctx: EggContext, req: CreateHookRequest): Promise<import("./convertor/HookConvertor.js").HookVo>;
-    updateHook(ctx: EggContext, id: string, req: UpdateHookRequest): Promise<import("./convertor/HookConvertor.js").HookVo>;
-    deleteHook(ctx: EggContext, id: string): Promise<import("./convertor/HookConvertor.js").DeleteHookVo>;
+    createHook(ctx: EggContext, req: CreateHookRequest): Promise<import("./convertor/HookConvertor.ts").HookVo>;
+    updateHook(ctx: EggContext, id: string, req: UpdateHookRequest): Promise<import("./convertor/HookConvertor.ts").HookVo>;
+    deleteHook(ctx: EggContext, id: string): Promise<import("./convertor/HookConvertor.ts").DeleteHookVo>;
     listHooks(ctx: EggContext): Promise<{
-        objects: import("./convertor/HookConvertor.js").HookVo[];
+        objects: import("./convertor/HookConvertor.ts").HookVo[];
     }>;
-    getHook(ctx: EggContext, id: string): Promise<import("./convertor/HookConvertor.js").HookVo>;
+    getHook(ctx: EggContext, id: string): Promise<import("./convertor/HookConvertor.ts").HookVo>;
 }

package/dist/app/port/controller/HookController.js

@@ -11,8 +11,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
-import { HookConvertor } from './convertor/HookConvertor.js';
-import { CreateHookRequestRule, UpdateHookRequestRule } from '../typebox.js';
+import { HookConvertor } from "./convertor/HookConvertor.js";
+import { CreateHookRequestRule, UpdateHookRequestRule } from "../typebox.js";
 let HookController = class HookController {
     async createHook(ctx, req) {
         ctx.tValidate(CreateHookRequestRule, req);

package/dist/app/port/controller/PackageBlockController.d.ts

@@ -1,6 +1,6 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from './AbstractController.js';
-import { type BlockPackageType } from '../typebox.js';
+import { AbstractController } from './AbstractController.ts';
+import { type BlockPackageType } from '../typebox.ts';
 export declare class PackageBlockController extends AbstractController {
     private packageManagerService;
     private packageVersionBlockRepository;

package/dist/app/port/controller/PackageBlockController.js

@@ -12,10 +12,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, Middleware, } from '@eggjs/tegg';
 import { ForbiddenError } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import { FULLNAME_REG_STRING } from '../../common/PackageUtil.js';
-import { BlockPackageRule } from '../typebox.js';
-import { AdminAccess } from '../middleware/AdminAccess.js';
+import { AbstractController } from "./AbstractController.js";
+import { FULLNAME_REG_STRING } from "../../common/PackageUtil.js";
+import { BlockPackageRule } from "../typebox.js";
+import { AdminAccess } from "../middleware/AdminAccess.js";
 let PackageBlockController = class PackageBlockController extends AbstractController {
     async blockPackage(ctx, fullname, data) {
         const params = { fullname, reason: data.reason };

package/dist/app/port/controller/PackageSyncController.d.ts

@@ -1,7 +1,7 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from './AbstractController.js';
-import { TaskState } from '../../common/enum/Task.js';
-import { type SyncPackageTaskType } from '../typebox.js';
+import { AbstractController } from './AbstractController.ts';
+import { TaskState } from '../../common/enum/Task.ts';
+import { type SyncPackageTaskType } from '../typebox.ts';
 export declare class PackageSyncController extends AbstractController {
     private packageSyncerService;
     private backgroundTaskHelper;
@@ -10,13 +10,13 @@ export declare class PackageSyncController extends AbstractController {
     createSyncTask(ctx: EggContext, fullname: string, data: SyncPackageTaskType): Promise<{
         ok: boolean;
         id: string;
-        type: import("../../common/enum/Task.js").TaskType;
+        type: import("../../common/enum/Task.ts").TaskType;
         state: TaskState;
     }>;
     showSyncTask(fullname: string, taskId: string): Promise<{
         ok: boolean;
         id: string;
-        type: import("../../common/enum/Task.js").TaskType;
+        type: import("../../common/enum/Task.ts").TaskType;
         state: TaskState;
         logUrl: string | undefined;
         error: string | undefined;

package/dist/app/port/controller/PackageSyncController.js

@@ -12,11 +12,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, HTTPQuery, Inject, } from '@eggjs/tegg';
 import { ForbiddenError, NotFoundError } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import { FULLNAME_REG_STRING, getScopeAndName, } from '../../common/PackageUtil.js';
-import { TaskState } from '../../common/enum/Task.js';
-import { SyncPackageTaskRule } from '../typebox.js';
-import { SyncMode } from '../../common/constants.js';
+import { AbstractController } from "./AbstractController.js";
+import { FULLNAME_REG_STRING, getScopeAndName, } from "../../common/PackageUtil.js";
+import { TaskState } from "../../common/enum/Task.js";
+import { SyncPackageTaskRule } from "../typebox.js";
+import { SyncMode } from "../../common/constants.js";
 let PackageSyncController = class PackageSyncController extends AbstractController {
     async _executeTaskAsync(task) {
         const startTime = Date.now();

package/dist/app/port/controller/PackageTagController.d.ts

@@ -1,5 +1,5 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from './AbstractController.js';
+import { AbstractController } from './AbstractController.ts';
 export declare class PackageTagController extends AbstractController {
     private packageManagerService;
     showTags(fullname: string): Promise<Record<string, string>>;

package/dist/app/port/controller/PackageTagController.js

@@ -12,9 +12,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
 import { ForbiddenError } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import { FULLNAME_REG_STRING } from '../../common/PackageUtil.js';
-import { TagRule, TagWithVersionRule } from '../typebox.js';
+import { AbstractController } from "./AbstractController.js";
+import { FULLNAME_REG_STRING } from "../../common/PackageUtil.js";
+import { TagRule, TagWithVersionRule } from "../typebox.js";
 let PackageTagController = class PackageTagController extends AbstractController {
     async showTags(fullname) {
         const packageEntity = await this.getPackageEntityByFullname(fullname);

package/dist/app/port/controller/PackageVersionFileController.d.ts

@@ -1,5 +1,5 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from './AbstractController.js';
+import { AbstractController } from './AbstractController.ts';
 interface FileItem {
     path: string;
     type: 'file';

package/dist/app/port/controller/PackageVersionFileController.js

@@ -19,11 +19,11 @@ var _PackageVersionFileController_instances, _PackageVersionFileController_requi
 import { join } from 'node:path';
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, HTTPQuery, Inject, Middleware, } from '@eggjs/tegg';
 import { NotFoundError } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import { AdminAccess } from '../middleware/AdminAccess.js';
-import { FULLNAME_REG_STRING, getScopeAndName, } from '../../common/PackageUtil.js';
-import { Spec } from '../typebox.js';
-import { ensureContentType } from '../../common/FileUtil.js';
+import { AbstractController } from "./AbstractController.js";
+import { AdminAccess } from "../middleware/AdminAccess.js";
+import { FULLNAME_REG_STRING, getScopeAndName, } from "../../common/PackageUtil.js";
+import { Spec } from "../typebox.js";
+import { ensureContentType } from "../../common/FileUtil.js";
 function formatFileItem(file) {
     return {
         path: file.path,

package/dist/app/port/controller/ProxyCacheController.d.ts

@@ -1,7 +1,7 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from './AbstractController.js';
+import { AbstractController } from './AbstractController.ts';
 import type { Static } from '@eggjs/typebox-validate/typebox';
-import type { QueryPageOptions } from '../typebox.js';
+import type { QueryPageOptions } from '../typebox.ts';
 export declare class ProxyCacheController extends AbstractController {
     private readonly proxyCacheRepository;
     private readonly proxyCacheService;

package/dist/app/port/controller/ProxyCacheController.js

@@ -12,10 +12,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, HTTPQuery, Inject, } from '@eggjs/tegg';
 import { ForbiddenError, NotFoundError, NotImplementedError, UnauthorizedError, } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import { FULLNAME_REG_STRING } from '../../common/PackageUtil.js';
-import { SyncMode } from '../../common/constants.js';
-import { isPkgManifest } from '../../core/entity/Package.js';
+import { AbstractController } from "./AbstractController.js";
+import { FULLNAME_REG_STRING } from "../../common/PackageUtil.js";
+import { SyncMode } from "../../common/constants.js";
+import { isPkgManifest } from "../../core/entity/Package.js";
 let ProxyCacheController = class ProxyCacheController extends AbstractController {
     async listProxyCache(pageSize, pageIndex) {
         if (this.config.cnpmcore.syncMode !== SyncMode.proxy) {

package/dist/app/port/controller/RegistryController.d.ts

@@ -1,8 +1,8 @@
 import { type EggContext } from '@eggjs/tegg';
 import type { Static } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from './AbstractController.js';
-import type { UpdateRegistryCmd } from '../../core/service/RegistryManagerService.js';
-import { RegistryCreateOptions, RegistryCreateSyncOptions, type QueryPageOptions } from '../typebox.js';
+import { AbstractController } from './AbstractController.ts';
+import type { UpdateRegistryCmd } from '../../core/service/RegistryManagerService.ts';
+import { RegistryCreateOptions, RegistryCreateSyncOptions, type QueryPageOptions } from '../typebox.ts';
 export declare class RegistryController extends AbstractController {
     private readonly registryManagerService;
     private readonly scopeManagerService;

package/dist/app/port/controller/RegistryController.js

@@ -12,9 +12,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, HTTPQuery, Inject, Middleware, } from '@eggjs/tegg';
 import { NotFoundError } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import { AdminAccess } from '../middleware/AdminAccess.js';
-import { RegistryCreateOptions, RegistryCreateSyncOptions, RegistryUpdateOptions, } from '../typebox.js';
+import { AbstractController } from "./AbstractController.js";
+import { AdminAccess } from "../middleware/AdminAccess.js";
+import { RegistryCreateOptions, RegistryCreateSyncOptions, RegistryUpdateOptions, } from "../typebox.js";
 let RegistryController = class RegistryController extends AbstractController {
     async listRegistries(pageSize, pageIndex) {
         const registries = await this.registryManagerService.listRegistries({

package/dist/app/port/controller/ScopeController.d.ts

@@ -1,7 +1,7 @@
 import { type EggContext } from '@eggjs/tegg';
 import type { Static } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from './AbstractController.js';
-import { ScopeCreateOptions } from '../typebox.js';
+import { AbstractController } from './AbstractController.ts';
+import { ScopeCreateOptions } from '../typebox.ts';
 export declare class ScopeController extends AbstractController {
     private readonly scopeManagerService;
     private readonly registryManagerService;

package/dist/app/port/controller/ScopeController.js

@@ -12,9 +12,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, Middleware, } from '@eggjs/tegg';
 import { E400 } from 'egg-errors';
-import { AbstractController } from './AbstractController.js';
-import { AdminAccess } from '../middleware/AdminAccess.js';
-import { ScopeCreateOptions } from '../typebox.js';
+import { AbstractController } from "./AbstractController.js";
+import { AdminAccess } from "../middleware/AdminAccess.js";
+import { ScopeCreateOptions } from "../typebox.js";
 let ScopeController = class ScopeController extends AbstractController {
     async createScope(ctx, scopeOptions) {
         const authorizedUser = await this.userRoleManager.requiredAuthorizedUser(ctx, 'setting');

package/dist/app/port/controller/TokenController.d.ts

@@ -1,7 +1,7 @@
 import { type EggContext } from '@eggjs/tegg';
 import { type Static } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from './AbstractController.js';
-import { TokenType } from '../../core/entity/Token.js';
+import { AbstractController } from './AbstractController.ts';
+import { TokenType } from '../../core/entity/Token.ts';
 declare const TokenOptionsRule: import("@eggjs/typebox-validate/typebox").TObject<{
     password: import("@eggjs/typebox-validate/typebox").TString;
     readonly: import("@eggjs/typebox-validate/typebox").TOptional<import("@eggjs/typebox-validate/typebox").TBoolean>;

package/dist/app/port/controller/TokenController.js

@@ -13,8 +13,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { ForbiddenError, UnauthorizedError } from 'egg-errors';
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
 import { Type } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from './AbstractController.js';
-import { TokenType, isGranularToken } from '../../core/entity/Token.js';
+import { AbstractController } from "./AbstractController.js";
+import { TokenType, isGranularToken } from "../../core/entity/Token.js";
 // Creating and viewing access tokens
 // https://docs.npmjs.com/creating-and-viewing-access-tokens#viewing-access-tokens
 const TokenOptionsRule = Type.Object({

package/dist/app/port/controller/UserController.d.ts

@@ -1,6 +1,6 @@
 import { type EggContext } from '@eggjs/tegg';
 import { type Static } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from './AbstractController.js';
+import { AbstractController } from './AbstractController.ts';
 declare const UserRule: import("@eggjs/typebox-validate/typebox").TObject<{
     type: import("@eggjs/typebox-validate/typebox").TLiteral<"user">;
     name: import("@eggjs/typebox-validate/typebox").TString;
@@ -36,7 +36,7 @@ export declare class UserController extends AbstractController {
         readonly: boolean;
         created: Date;
         updated: Date;
-        type: import("../../core/entity/Token.js").TokenType | undefined;
+        type: import("../../core/entity/Token.ts").TokenType | undefined;
     } | {
         username: string;
         name?: undefined;

package/dist/app/port/controller/UserController.js

@@ -13,10 +13,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, } from '@eggjs/tegg';
 import { ForbiddenError, NotFoundError, UnauthorizedError, UnprocessableEntityError, } from 'egg-errors';
 import { Type } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from './AbstractController.js';
-import { LoginResultCode } from '../../common/enum/User.js';
-import { sha512 } from '../../common/UserUtil.js';
-import { isGranularToken } from '../../core/entity/Token.js';
+import { AbstractController } from "./AbstractController.js";
+import { LoginResultCode } from "../../common/enum/User.js";
+import { sha512 } from "../../common/UserUtil.js";
+import { isGranularToken } from "../../core/entity/Token.js";
 // body: {
 //   _id: 'org.couchdb.user:dddd',
 //   name: 'dddd',

package/dist/app/port/controller/admin/PaddingVersionController.d.ts

@@ -1,5 +1,5 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
+import { AbstractController } from '../AbstractController.ts';
 export declare class PaddingVersionController extends AbstractController {
     private readonly fixNoPaddingVersionService;
     fixNoPaddingVersion(ctx: EggContext, id: string): Promise<{

package/dist/app/port/controller/admin/PaddingVersionController.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPQuery, Inject, } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
+import { AbstractController } from "../AbstractController.js";
 let PaddingVersionController = class PaddingVersionController extends AbstractController {
     async fixNoPaddingVersion(ctx, id) {
         const isAdmin = await this.userRoleManager.isAdmin(ctx);

package/dist/app/port/controller/convertor/HookConvertor.d.ts

@@ -1,7 +1,7 @@
-import type { Hook } from '../../../core/entity/Hook.js';
-import type { TriggerHookTask } from '../../../core/entity/Task.js';
-import type { User } from '../../../core/entity/User.js';
-import type { HookType } from '../../../common/enum/Hook.js';
+import type { Hook } from '../../../core/entity/Hook.ts';
+import type { TriggerHookTask } from '../../../core/entity/Task.ts';
+import type { User } from '../../../core/entity/User.ts';
+import type { HookType } from '../../../common/enum/Hook.ts';
 export interface HookVo {
     id: string;
     username: string;

package/dist/app/port/controller/package/DownloadPackageVersionTar.d.ts

@@ -1,6 +1,6 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
-import type { RegistryManagerService } from '../../../core/service/RegistryManagerService.js';
+import { AbstractController } from '../AbstractController.ts';
+import type { RegistryManagerService } from '../../../core/service/RegistryManagerService.ts';
 export declare class DownloadPackageVersionTarController extends AbstractController {
     private packageManagerService;
     registryManagerService: RegistryManagerService;

package/dist/app/port/controller/package/DownloadPackageVersionTar.js

@@ -13,9 +13,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { PassThrough } from 'node:stream';
 import { NotFoundError } from 'egg-errors';
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
-import { FULLNAME_REG_STRING, getScopeAndName, } from '../../../common/PackageUtil.js';
-import { SyncMode } from '../../../common/constants.js';
+import { AbstractController } from "../AbstractController.js";
+import { FULLNAME_REG_STRING, getScopeAndName, } from "../../../common/PackageUtil.js";
+import { SyncMode } from "../../../common/constants.js";
 let DownloadPackageVersionTarController = class DownloadPackageVersionTarController extends AbstractController {
     // Support OPTIONS Request on tgz download
     async downloadForOptions(ctx) {

package/dist/app/port/controller/package/RemovePackageVersionController.d.ts

@@ -1,5 +1,5 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
+import { AbstractController } from '../AbstractController.ts';
 export declare class RemovePackageVersionController extends AbstractController {
     #private;
     private packageManagerService;

package/dist/app/port/controller/package/RemovePackageVersionController.js

@@ -18,8 +18,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _RemovePackageVersionController_instances, _RemovePackageVersionController_removePackageVersion;
 import { BadRequestError, ForbiddenError } from 'egg-errors';
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
-import { FULLNAME_REG_STRING } from '../../../common/PackageUtil.js';
+import { AbstractController } from "../AbstractController.js";
+import { FULLNAME_REG_STRING } from "../../../common/PackageUtil.js";
 let RemovePackageVersionController = class RemovePackageVersionController extends AbstractController {
     constructor() {
         super(...arguments);

package/dist/app/port/controller/package/SavePackageVersionController.d.ts

@@ -1,7 +1,7 @@
 import type { PackageJson, Simplify } from 'type-fest';
 import { type EggContext } from '@eggjs/tegg';
 import { type Static } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from '../AbstractController.js';
+import { AbstractController } from '../AbstractController.ts';
 type PackageVersion = Simplify<PackageJson.PackageJsonStandard & {
     name: 'string';
     version: 'string';

package/dist/app/port/controller/package/SavePackageVersionController.js

@@ -16,9 +16,9 @@ import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPPara
 import { checkData, fromData } from 'ssri';
 import validateNpmPackageName from 'validate-npm-package-name';
 import { Type } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from '../AbstractController.js';
-import { FULLNAME_REG_STRING, extractPackageJSON, getScopeAndName, } from '../../../common/PackageUtil.js';
-import { Description as DescriptionType, Name as NameType, TagWithVersionRule, VersionRule, } from '../../typebox.js';
+import { AbstractController } from "../AbstractController.js";
+import { FULLNAME_REG_STRING, extractPackageJSON, getScopeAndName, } from "../../../common/PackageUtil.js";
+import { Description as DescriptionType, Name as NameType, TagWithVersionRule, VersionRule, } from "../../typebox.js";
 const STRICT_CHECK_TARBALL_FIELDS = [
     'name',
     'version',

package/dist/app/port/controller/package/SearchPackageController.d.ts

@@ -1,7 +1,7 @@
 import { type EggContext } from '@eggjs/tegg';
 import type { Static } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from '../AbstractController.js';
-import type { SearchQueryOptions } from '../../typebox.js';
+import { AbstractController } from '../AbstractController.ts';
+import type { SearchQueryOptions } from '../../typebox.ts';
 export declare class SearchPackageController extends AbstractController {
     private readonly packageSearchService;
     search(ctx: EggContext, text: Static<typeof SearchQueryOptions>['text'], from: Static<typeof SearchQueryOptions>['from'], size: Static<typeof SearchQueryOptions>['size']): Promise<{

package/dist/app/port/controller/package/SearchPackageController.js

@@ -12,9 +12,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, HTTPQuery, Inject, Middleware, } from '@eggjs/tegg';
 import { E451 } from 'egg-errors';
-import { AbstractController } from '../AbstractController.js';
-import { FULLNAME_REG_STRING } from '../../../common/PackageUtil.js';
-import { AdminAccess } from '../../middleware/AdminAccess.js';
+import { AbstractController } from "../AbstractController.js";
+import { FULLNAME_REG_STRING } from "../../../common/PackageUtil.js";
+import { AdminAccess } from "../../middleware/AdminAccess.js";
 let SearchPackageController = class SearchPackageController extends AbstractController {
     async search(ctx, text, from, size) {
         if (!this.config.cnpmcore.enableElasticsearch) {

package/dist/app/port/controller/package/ShowPackageController.d.ts

@@ -1,5 +1,5 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
+import { AbstractController } from '../AbstractController.ts';
 export declare class ShowPackageController extends AbstractController {
     private packageManagerService;
     private cacheService;

package/dist/app/port/controller/package/ShowPackageController.js

@@ -11,11 +11,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
-import { FULLNAME_REG_STRING, getScopeAndName, calculateIntegrity, } from '../../../common/PackageUtil.js';
-import { isSyncWorkerRequest } from '../../../common/SyncUtil.js';
-import { ABBREVIATED_META_TYPE, SyncMode } from '../../../common/constants.js';
-import { DIST_NAMES } from '../../../core/entity/Package.js';
+import { AbstractController } from "../AbstractController.js";
+import { FULLNAME_REG_STRING, getScopeAndName, calculateIntegrity, } from "../../../common/PackageUtil.js";
+import { isSyncWorkerRequest } from "../../../common/SyncUtil.js";
+import { ABBREVIATED_META_TYPE, SyncMode } from "../../../common/constants.js";
+import { DIST_NAMES } from "../../../core/entity/Package.js";
 let ShowPackageController = class ShowPackageController extends AbstractController {
     async show(ctx, fullname) {
         const [scope, name] = getScopeAndName(fullname);

package/dist/app/port/controller/package/ShowPackageVersionController.d.ts

@@ -1,5 +1,5 @@
 import { type EggContext } from '@eggjs/tegg';
-import { AbstractController } from '../AbstractController.js';
+import { AbstractController } from '../AbstractController.ts';
 export declare class ShowPackageVersionController extends AbstractController {
     private packageManagerService;
     private proxyCacheService;

package/dist/app/port/controller/package/ShowPackageVersionController.js

@@ -12,12 +12,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Context, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
 import { NotFoundError } from 'egg-errors';
-import { AbstractController } from '../AbstractController.js';
-import { FULLNAME_REG_STRING, getScopeAndName, } from '../../../common/PackageUtil.js';
-import { isSyncWorkerRequest } from '../../../common/SyncUtil.js';
-import { Spec } from '../../../port/typebox.js';
-import { ABBREVIATED_META_TYPE, SyncMode } from '../../../common/constants.js';
-import { DIST_NAMES } from '../../../core/entity/Package.js';
+import { AbstractController } from "../AbstractController.js";
+import { FULLNAME_REG_STRING, getScopeAndName, } from "../../../common/PackageUtil.js";
+import { isSyncWorkerRequest } from "../../../common/SyncUtil.js";
+import { Spec } from "../../../port/typebox.js";
+import { ABBREVIATED_META_TYPE, SyncMode } from "../../../common/constants.js";
+import { DIST_NAMES } from "../../../core/entity/Package.js";
 let ShowPackageVersionController = class ShowPackageVersionController extends AbstractController {
     async show(ctx, fullname, versionSpec) {
         // https://github.com/npm/registry/blob/master/docs/responses/package-metadata.md#full-metadata-format

package/dist/app/port/controller/package/UpdatePackageController.d.ts

@@ -1,6 +1,6 @@
 import { type EggContext } from '@eggjs/tegg';
 import { type Static } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from '../AbstractController.js';
+import { AbstractController } from '../AbstractController.ts';
 declare const MaintainerDataRule: import("@eggjs/typebox-validate/typebox").TObject<{
     maintainers: import("@eggjs/typebox-validate/typebox").TArray<import("@eggjs/typebox-validate/typebox").TObject<{
         name: import("@eggjs/typebox-validate/typebox").TString;

package/dist/app/port/controller/package/UpdatePackageController.js

@@ -13,8 +13,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { BadRequestError, UnprocessableEntityError } from 'egg-errors';
 import { Context, HTTPBody, HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam, Inject, } from '@eggjs/tegg';
 import { Type } from '@eggjs/typebox-validate/typebox';
-import { AbstractController } from '../AbstractController.js';
-import { FULLNAME_REG_STRING } from '../../../common/PackageUtil.js';
+import { AbstractController } from "../AbstractController.js";
+import { FULLNAME_REG_STRING } from "../../../common/PackageUtil.js";
 const MaintainerDataRule = Type.Object({
     maintainers: Type.Array(Type.Object({
         name: Type.String({ minLength: 1, maxLength: 100 }),

package/dist/app/port/middleware/AdminAccess.js

@@ -1,5 +1,5 @@
 import { ForbiddenError } from 'egg-errors';
-import { UserRoleManager } from '../UserRoleManager.js';
+import { UserRoleManager } from "../UserRoleManager.js";
 export async function AdminAccess(ctx, next) {
     const userRoleManager = await ctx.getEggObject(UserRoleManager);
     const isAdmin = await userRoleManager.isAdmin(ctx);

package/dist/app/port/middleware/AlwaysAuth.js

@@ -1,4 +1,4 @@
-import { UserRoleManager } from '../UserRoleManager.js';
+import { UserRoleManager } from "../UserRoleManager.js";
 export async function AlwaysAuth(ctx, next) {
     if (ctx.app.config.cnpmcore.alwaysAuth) {
         // ignore login request: `PUT /-/user/org.couchdb.user::username`