@solar-angular/planets 1.0.0

package/README.md

@@ -0,0 +1,7 @@
+# planets
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test planets` to execute the unit tests.

package/earth/earth.pipe.d.ts

@@ -0,0 +1,19 @@
+import { ChangeDetectorRef, PipeTransform } from '@angular/core';
+import { Category, Origin } from '@solar-kit/planets/earth';
+import { EarthService } from './earth.service';
+import * as i0 from "@angular/core";
+export declare class CategoryPipe implements PipeTransform {
+    protected latestId: Category['id'] | null;
+    protected latestOrigin: Origin | null;
+    protected latestValue: Category | null;
+    protected readonly service: EarthService;
+    protected readonly cdr: ChangeDetectorRef;
+    transform(id: Category['id'], origin: Origin): Category | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategoryPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CategoryPipe, "category", true>;
+}
+export declare class UnitCategoryPipe extends CategoryPipe implements PipeTransform {
+    transform(value: Category['id']): Category | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnitCategoryPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UnitCategoryPipe, "unit", true>;
+}

package/earth/earth.resolver.d.ts

@@ -0,0 +1,4 @@
+import { ResolveFn } from '@angular/router';
+import { Category, Channel, Origin } from '@solar-kit/planets/earth';
+export declare function channelResolver(origin: Origin): ResolveFn<Channel[]>;
+export declare function categoryResolver(origin: Origin): ResolveFn<Category[]>;

package/earth/earth.service.d.ts

@@ -0,0 +1,32 @@
+import { HttpClient } from '@angular/common/http';
+import { UrlSegment } from '@angular/router';
+import { CacheManager } from '@solar-angular/http';
+import { AccountName, Address, Category, Channel, Menu, Origin, UploadKeys, UserInfo } from '@solar-kit/planets/earth';
+import { Result } from '@solar-kit/planets/sun';
+import * as i0 from "@angular/core";
+export declare class EarthService {
+    readonly config: import("@solar-angular/core").SolarConfig;
+    readonly http: HttpClient;
+    readonly cacheManager: CacheManager;
+    checkAuth(): import("rxjs").Observable<boolean>;
+    checkPermission(segments: UrlSegment[]): import("rxjs").Observable<boolean>;
+    account(): import("rxjs").Observable<Result<AccountName>>;
+    user(): import("rxjs").Observable<Result<UserInfo>>;
+    menus(): import("rxjs").Observable<Menu[]>;
+    /**
+     * 变更密码
+     * @param o
+     * @returns
+     */
+    changePassword(o: {
+        oldPsw: string;
+        newPsw: string;
+    }): import("rxjs").Observable<Result<null>>;
+    channels(origin: Origin): import("rxjs").Observable<Result<Channel[]>>;
+    categories(origin: Origin): import("rxjs").Observable<Result<Category[]>>;
+    address(pid?: number): import("rxjs").Observable<Result<Address[]>>;
+    avatarUploadKey(): import("rxjs").Observable<Result<UploadKeys>>;
+    mediaUploadKeys(keySize?: number): import("rxjs").Observable<Result<UploadKeys>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EarthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EarthService>;
+}

package/earth/guards/auth.guard.d.ts

@@ -0,0 +1,12 @@
+import { CanMatchFn } from '@angular/router';
+interface AuthMatchGuardOptions {
+    /** 是否在登陆后重定向回当前页 */
+    redirect?: boolean;
+}
+/**
+ * 认证路由守卫
+ * 认证后才允许进入，否则将导航到登录页（/login）
+ * @param options
+ */
+export declare function authMatchGuard(options?: AuthMatchGuardOptions): CanMatchFn;
+export {};

package/earth/guards/index.d.ts

@@ -0,0 +1,3 @@
+export * from './auth.guard';
+export * from './permission.guard';
+export * from './unauth.guard';

package/earth/guards/permission.guard.d.ts

@@ -0,0 +1,6 @@
+import { CanMatchFn } from '@angular/router';
+/**
+ * 权限路由守卫
+ * 有权限才允许进入，否则导航到无权限页（/forbidden）
+ */
+export declare function permissionMatchGuard(): CanMatchFn;

package/earth/guards/unauth.guard.d.ts

@@ -0,0 +1,6 @@
+import { CanMatchFn } from '@angular/router';
+/**
+ * 未认证路由守卫
+ * 未认证才允许进入，否则将导航到首页
+ */
+export declare function unauthMatchGuard(): CanMatchFn;

package/earth/index.d.ts

@@ -0,0 +1,6 @@
+export * from './earth.pipe';
+export * from './earth.resolver';
+export * from './earth.service';
+export * from './guards';
+export * from './menu.service';
+export * from './object-storage.service';

package/earth/menu.service.d.ts

@@ -0,0 +1,14 @@
+import { Menu } from '@solar-kit/planets/earth';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class MenuService {
+    private readonly earthService;
+    private readonly router;
+    private get pureUrl();
+    /**
+     * 当前的菜单数组
+     */
+    readonly menus$: Observable<Menu[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MenuService>;
+}

package/earth/object-storage.service.d.ts

@@ -0,0 +1,21 @@
+import { UploadKeys } from '@solar-kit/planets/earth';
+import * as i0 from "@angular/core";
+export declare class ObjectStorageService {
+    private readonly http;
+    /**
+     * 目前只支持了 qiniu oss
+     * @param filePath
+     * @param options
+     * @returns
+     */
+    upload(file: Blob, key: string, options: Pick<UploadKeys, 'host' | 'token'>): import("rxjs").Observable<{
+        hash: string;
+        key: string;
+    }>;
+    uploadWithEvents(file: Blob, key: string, options: Pick<UploadKeys, 'host' | 'token'>): import("rxjs").Observable<import("@angular/common/http").HttpEvent<{
+        hash: string;
+        key: string;
+    }>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectStorageService>;
+}

package/esm2022/earth/earth.pipe.mjs

@@ -0,0 +1,51 @@
+import { ChangeDetectorRef, inject, Pipe } from '@angular/core';
+import { filterResult } from '@solar-kit/planets/sun';
+import { EarthService } from './earth.service';
+import * as i0 from "@angular/core";
+export class CategoryPipe {
+    constructor() {
+        this.latestId = null;
+        this.latestOrigin = null;
+        this.latestValue = null;
+        this.service = inject(EarthService);
+        this.cdr = inject(ChangeDetectorRef);
+    }
+    transform(id, origin) {
+        if (id !== this.latestId || origin !== this.latestOrigin) {
+            this.latestId = id;
+            this.latestOrigin = origin;
+            // 这个 API 是带缓存的，不用担心重复执行
+            this.service.categories(origin).pipe(filterResult()).subscribe(({ data }) => {
+                this.latestValue = data.find(o => o.id === id) ?? null;
+                this.cdr.markForCheck();
+            });
+        }
+        return this.latestValue;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CategoryPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: CategoryPipe, isStandalone: true, name: "category", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CategoryPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'category',
+                    pure: false,
+                    standalone: true
+                }]
+        }] });
+export class UnitCategoryPipe extends CategoryPipe {
+    transform(value) {
+        return super.transform(value, 13 /* Origin.Unit */);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UnitCategoryPipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: UnitCategoryPipe, isStandalone: true, name: "unit", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UnitCategoryPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'unit',
+                    pure: false,
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWFydGgucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL3BsYW5ldHMvZWFydGgvZWFydGgucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFFL0UsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3RELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7QUFPL0MsTUFBTSxPQUFPLFlBQVk7SUFMekI7UUFNWSxhQUFRLEdBQTBCLElBQUksQ0FBQztRQUN2QyxpQkFBWSxHQUFrQixJQUFJLENBQUM7UUFDbkMsZ0JBQVcsR0FBb0IsSUFBSSxDQUFDO1FBQzNCLFlBQU8sR0FBRyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDL0IsUUFBRyxHQUFHLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0tBbUJwRDtJQWpCQyxTQUFTLENBQUMsRUFBa0IsRUFBRSxNQUFjO1FBQzFDLElBQUksRUFBRSxLQUFLLElBQUksQ0FBQyxRQUFRLElBQUksTUFBTSxLQUFLLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUN6RCxJQUFJLENBQUMsUUFBUSxHQUFHLEVBQUUsQ0FBQztZQUNuQixJQUFJLENBQUMsWUFBWSxHQUFHLE1BQU0sQ0FBQztZQUUzQix3QkFBd0I7WUFDeEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUNsQyxZQUFZLEVBQUUsQ0FDZixDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRTtnQkFDdkIsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUMsSUFBSSxJQUFJLENBQUM7Z0JBQ3ZELElBQUksQ0FBQyxHQUFHLENBQUMsWUFBWSxFQUFFLENBQUM7WUFDMUIsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQzFCLENBQUM7K0dBdEJVLFlBQVk7NkdBQVosWUFBWTs7NEZBQVosWUFBWTtrQkFMeEIsSUFBSTttQkFBQztvQkFDSixJQUFJLEVBQUUsVUFBVTtvQkFDaEIsSUFBSSxFQUFFLEtBQUs7b0JBQ1gsVUFBVSxFQUFFLElBQUk7aUJBQ2pCOztBQWdDRCxNQUFNLE9BQU8sZ0JBQWlCLFNBQVEsWUFBWTtJQUN2QyxTQUFTLENBQUMsS0FBcUI7UUFDdEMsT0FBTyxLQUFLLENBQUMsU0FBUyxDQUFDLEtBQUssdUJBQWMsQ0FBQztJQUM3QyxDQUFDOytHQUhVLGdCQUFnQjs2R0FBaEIsZ0JBQWdCOzs0RkFBaEIsZ0JBQWdCO2tCQUw1QixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxNQUFNO29CQUNaLElBQUksRUFBRSxLQUFLO29CQUNYLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdG9yUmVmLCBpbmplY3QsIFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENhdGVnb3J5LCBPcmlnaW4gfSBmcm9tICdAc29sYXIta2l0L3BsYW5ldHMvZWFydGgnO1xuaW1wb3J0IHsgZmlsdGVyUmVzdWx0IH0gZnJvbSAnQHNvbGFyLWtpdC9wbGFuZXRzL3N1bic7XG5pbXBvcnQgeyBFYXJ0aFNlcnZpY2UgfSBmcm9tICcuL2VhcnRoLnNlcnZpY2UnO1xuXG5AUGlwZSh7XG4gIG5hbWU6ICdjYXRlZ29yeScsXG4gIHB1cmU6IGZhbHNlLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIENhdGVnb3J5UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICBwcm90ZWN0ZWQgbGF0ZXN0SWQ6IENhdGVnb3J5WydpZCddIHwgbnVsbCA9IG51bGw7XG4gIHByb3RlY3RlZCBsYXRlc3RPcmlnaW46IE9yaWdpbiB8IG51bGwgPSBudWxsO1xuICBwcm90ZWN0ZWQgbGF0ZXN0VmFsdWU6IENhdGVnb3J5IHwgbnVsbCA9IG51bGw7XG4gIHByb3RlY3RlZCByZWFkb25seSBzZXJ2aWNlID0gaW5qZWN0KEVhcnRoU2VydmljZSk7XG4gIHByb3RlY3RlZCByZWFkb25seSBjZHIgPSBpbmplY3QoQ2hhbmdlRGV0ZWN0b3JSZWYpO1xuXG4gIHRyYW5zZm9ybShpZDogQ2F0ZWdvcnlbJ2lkJ10sIG9yaWdpbjogT3JpZ2luKSB7XG4gICAgaWYgKGlkICE9PSB0aGlzLmxhdGVzdElkIHx8IG9yaWdpbiAhPT0gdGhpcy5sYXRlc3RPcmlnaW4pIHtcbiAgICAgIHRoaXMubGF0ZXN0SWQgPSBpZDtcbiAgICAgIHRoaXMubGF0ZXN0T3JpZ2luID0gb3JpZ2luO1xuXG4gICAgICAvLyDov5nkuKogQVBJIOaYr+W4pue8k+WtmOeahO+8jOS4jeeUqOaLheW/g+mHjeWkjeaJp+ihjFxuICAgICAgdGhpcy5zZXJ2aWNlLmNhdGVnb3JpZXMob3JpZ2luKS5waXBlKFxuICAgICAgICBmaWx0ZXJSZXN1bHQoKVxuICAgICAgKS5zdWJzY3JpYmUoKHsgZGF0YSB9KSA9PiB7XG4gICAgICAgIHRoaXMubGF0ZXN0VmFsdWUgPSBkYXRhLmZpbmQobyA9PiBvLmlkID09PSBpZCkgPz8gbnVsbDtcbiAgICAgICAgdGhpcy5jZHIubWFya0ZvckNoZWNrKCk7XG4gICAgICB9KTtcbiAgICB9XG5cbiAgICByZXR1cm4gdGhpcy5sYXRlc3RWYWx1ZTtcbiAgfVxuXG59XG5cbkBQaXBlKHtcbiAgbmFtZTogJ3VuaXQnLFxuICBwdXJlOiBmYWxzZSxcbiAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBVbml0Q2F0ZWdvcnlQaXBlIGV4dGVuZHMgQ2F0ZWdvcnlQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIG92ZXJyaWRlIHRyYW5zZm9ybSh2YWx1ZTogQ2F0ZWdvcnlbJ2lkJ10pIHtcbiAgICByZXR1cm4gc3VwZXIudHJhbnNmb3JtKHZhbHVlLCBPcmlnaW4uVW5pdCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/earth/earth.resolver.mjs

@@ -0,0 +1,10 @@
+import { inject } from '@angular/core';
+import { unpackResult } from '@solar-kit/planets/sun';
+import { EarthService } from './earth.service';
+export function channelResolver(origin) {
+    return () => inject(EarthService).channels(origin).pipe(unpackResult());
+}
+export function categoryResolver(origin) {
+    return () => inject(EarthService).categories(origin).pipe(unpackResult());
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWFydGgucmVzb2x2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wbGFuZXRzL2VhcnRoL2VhcnRoLnJlc29sdmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHdkMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3RELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxNQUFNLFVBQVUsZUFBZSxDQUFDLE1BQWM7SUFDNUMsT0FBTyxHQUFHLEVBQUUsQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDO0FBQzFFLENBQUM7QUFFRCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsTUFBYztJQUM3QyxPQUFPLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDLENBQUM7QUFDNUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUmVzb2x2ZUZuIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IENhdGVnb3J5LCBDaGFubmVsLCBPcmlnaW4gfSBmcm9tICdAc29sYXIta2l0L3BsYW5ldHMvZWFydGgnO1xuaW1wb3J0IHsgdW5wYWNrUmVzdWx0IH0gZnJvbSAnQHNvbGFyLWtpdC9wbGFuZXRzL3N1bic7XG5pbXBvcnQgeyBFYXJ0aFNlcnZpY2UgfSBmcm9tICcuL2VhcnRoLnNlcnZpY2UnO1xuXG5leHBvcnQgZnVuY3Rpb24gY2hhbm5lbFJlc29sdmVyKG9yaWdpbjogT3JpZ2luKTogUmVzb2x2ZUZuPENoYW5uZWxbXT4ge1xuICByZXR1cm4gKCkgPT4gaW5qZWN0KEVhcnRoU2VydmljZSkuY2hhbm5lbHMob3JpZ2luKS5waXBlKHVucGFja1Jlc3VsdCgpKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGNhdGVnb3J5UmVzb2x2ZXIob3JpZ2luOiBPcmlnaW4pOiBSZXNvbHZlRm48Q2F0ZWdvcnlbXT4ge1xuICByZXR1cm4gKCkgPT4gaW5qZWN0KEVhcnRoU2VydmljZSkuY2F0ZWdvcmllcyhvcmlnaW4pLnBpcGUodW5wYWNrUmVzdWx0KCkpO1xufVxuIl19

package/esm2022/earth/earth.service.mjs

@@ -0,0 +1,134 @@
+import { HttpClient, HttpContext } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { SOLAR_CONFIG, tree2list } from '@solar-angular/core';
+import { AUTH_REDIRECT_TOKEN, CACHEABLE_TOKEN, CacheManager, CATCH_HTTP_ERROR_TOKEN } from '@solar-angular/http';
+import { filterResult } from '@solar-kit/planets/sun';
+import { catchError, map, of, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+function normalizeMenus(menus) {
+    const dashboard = {
+        id: 0,
+        fullName: 'Dashboard',
+        icon: 'dashboard',
+        seq: 0,
+        url: 'dashboard',
+    };
+    menus = menus.concat(dashboard);
+    menus.forEach(o => {
+        o.level = 1;
+        o.children = menus.filter(child => child.pid === o.id).sort((a, b) => a.seq - b.seq);
+        o.children.forEach(child => child.parent = o);
+    });
+    // 设置 level
+    menus.forEach(o => {
+        let menu = o;
+        while (menu?.parent) { // 如果有上一级，就自增一
+            o.level++;
+            menu = menu.parent;
+        }
+    });
+    // 设置末端子节点的 path
+    menus.filter(o => o.children?.length === 0).forEach(o => {
+        let segment = '', menu = o;
+        while (menu) {
+            segment = '/' + menu.url + segment;
+            menu = menu.parent;
+        }
+        o.path = segment;
+    });
+    menus.sort((a, b) => a.seq - b.seq);
+    return menus;
+}
+export class EarthService {
+    constructor() {
+        this.config = inject(SOLAR_CONFIG);
+        this.http = inject(HttpClient);
+        this.cacheManager = inject(CacheManager);
+    }
+    checkAuth() {
+        // 这里直接用 menus API 来判断是否已认证
+        return this.http.get(`${this.config.earthUrl}/api/role-menus/${this.config.clientId}`, {
+            context: new HttpContext()
+                .set(CACHEABLE_TOKEN, true)
+                .set(AUTH_REDIRECT_TOKEN, false)
+                .set(CATCH_HTTP_ERROR_TOKEN, false)
+        }).pipe(map(() => true), catchError(() => of(false)));
+    }
+    checkPermission(segments) {
+        return this.http.get(`${this.config.earthUrl}/api/role-menus/${this.config.clientId}`, {
+            context: new HttpContext()
+                .set(CACHEABLE_TOKEN, true)
+                .set(AUTH_REDIRECT_TOKEN, false)
+                .set(CATCH_HTTP_ERROR_TOKEN, false)
+        }).pipe(map(({ data }) => {
+            const tree = normalizeMenus(data);
+            const list = tree2list(tree);
+            // 我们的权限菜单只有两级，我们只判断前两个 path 片段
+            const path = '/' + segments
+                .filter((_, index) => index <= 1)
+                .map(o => o.path.replace(/;.+$/, '')) // path 中可能有参数，我们只取前面的部分：/a;id=1 => /a
+                .join('/');
+            return list.some(menu => menu.path === path);
+        }), catchError(() => of(false)));
+    }
+    account() {
+        return this.http.get(`${this.config.earthUrl}/api/acc/info`, {
+            context: new HttpContext().set(CACHEABLE_TOKEN, true)
+        });
+    }
+    user() {
+        return this.http.get(`${this.config.earthUrl}/api/usr/info`, {
+            context: new HttpContext().set(CACHEABLE_TOKEN, true)
+        });
+    }
+    menus() {
+        return this.http.get(`${this.config.earthUrl}/api/role-menus/${this.config.clientId}`, {
+            context: new HttpContext().set(CACHEABLE_TOKEN, true)
+        }).pipe(filterResult(), map(({ data }) => normalizeMenus(data)));
+    }
+    /**
+     * 变更密码
+     * @param o
+     * @returns
+     */
+    changePassword(o) {
+        return this.http.post(`${this.config.earthUrl}/api/user/psw`, o).pipe(tap(({ code }) => {
+            if (code === 0) {
+                this.cacheManager.revokeAll();
+            }
+        }));
+    }
+    channels(origin) {
+        return this.http.get(`${this.config.earthUrl}/api/channel/${origin}`, {
+            context: new HttpContext().set(CACHEABLE_TOKEN, true)
+        });
+    }
+    categories(origin) {
+        return this.http.get(`${this.config.earthUrl}/api/category/${origin}`, {
+            context: new HttpContext().set(CACHEABLE_TOKEN, true)
+        });
+    }
+    address(pid) {
+        return this.http.get(`${this.config.earthUrl}/api/addrs`, {
+            params: pid ? { pid } : undefined,
+            context: new HttpContext().set(CACHEABLE_TOKEN, true)
+        });
+    }
+    avatarUploadKey() {
+        return this.http.get(`${this.config.earthUrl}/api/qiniu/avatar/upload-key`);
+    }
+    mediaUploadKeys(keySize = 1) {
+        return this.http.get(`${this.config.earthUrl}/api/qiniu/media/upload-keys`, {
+            params: { keySize }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EarthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EarthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EarthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"earth.service.js","sourceRoot":"","sources":["../../../../packages/planets/earth/earth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpContext } from '@angular/common/http';\nimport { inject, Injectable } from '@angular/core';\nimport { UrlSegment } from '@angular/router';\nimport { SOLAR_CONFIG, tree2list } from '@solar-angular/core';\nimport { AUTH_REDIRECT_TOKEN, CACHEABLE_TOKEN, CacheManager, CATCH_HTTP_ERROR_TOKEN } from '@solar-angular/http';\nimport { AccountName, Address, Category, Channel, Menu, Origin, UploadKeys, UserInfo } from '@solar-kit/planets/earth';\nimport { filterResult, Result } from '@solar-kit/planets/sun';\nimport { catchError, map, of, tap } from 'rxjs';\n\nfunction normalizeMenus(menus: Menu[]) {\n  const dashboard = {\n    id: 0,\n    fullName: 'Dashboard',\n    icon: 'dashboard',\n    seq: 0,\n    url: 'dashboard',\n  } as Menu;\n\n  menus = menus.concat(dashboard);\n\n  menus.forEach(o => {\n    o.level = 1;\n    o.children = menus.filter(child => child.pid === o.id).sort((a, b) => a.seq - b.seq);\n    o.children!.forEach(child => child.parent = o);\n  });\n\n  // 设置 level\n  menus.forEach(o => {\n    let menu = o;\n    while (menu?.parent) { // 如果有上一级，就自增一\n      o.level!++;\n      menu = menu.parent;\n    }\n  });\n\n  // 设置末端子节点的 path\n  menus.filter(o => o.children?.length === 0).forEach(o => {\n    let segment = '', menu: Menu | undefined = o;\n\n    while (menu) {\n      segment = '/' + menu.url + segment;\n      menu = menu.parent;\n    }\n\n    o.path = segment;\n  });\n\n  menus.sort((a, b) => a.seq - b.seq);\n\n  return menus;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class EarthService {\n  readonly config = inject(SOLAR_CONFIG);\n  readonly http = inject(HttpClient);\n  readonly cacheManager = inject(CacheManager);\n\n  checkAuth() {\n    // 这里直接用 menus API 来判断是否已认证\n    return this.http.get<Result<Menu[]>>(`${this.config.earthUrl}/api/role-menus/${this.config.clientId}`, {\n      context: new HttpContext()\n        .set(CACHEABLE_TOKEN, true)\n        .set(AUTH_REDIRECT_TOKEN, false)\n        .set(CATCH_HTTP_ERROR_TOKEN, false)\n    }).pipe(\n      map(() => true),\n      catchError(() => of(false))\n    );\n  }\n\n  checkPermission(segments: UrlSegment[]) {\n    return this.http.get<Result<Menu[]>>(`${this.config.earthUrl}/api/role-menus/${this.config.clientId}`, {\n      context: new HttpContext()\n        .set(CACHEABLE_TOKEN, true)\n        .set(AUTH_REDIRECT_TOKEN, false)\n        .set(CATCH_HTTP_ERROR_TOKEN, false)\n    }).pipe(\n      map(({ data }) => {\n        const tree = normalizeMenus(data);\n        const list = tree2list(tree);\n        // 我们的权限菜单只有两级，我们只判断前两个 path 片段\n        const path = '/' + segments\n          .filter((_, index) => index <= 1)\n          .map(o => o.path.replace(/;.+$/, '')) // path 中可能有参数，我们只取前面的部分：/a;id=1 => /a\n          .join('/');\n        return list.some(menu => menu.path === path);\n      }),\n      catchError(() => of(false))\n    );\n  }\n\n  account() {\n    return this.http.get<Result<AccountName>>(`${this.config.earthUrl}/api/acc/info`, {\n      context: new HttpContext().set(CACHEABLE_TOKEN, true)\n    });\n  }\n\n  user() {\n    return this.http.get<Result<UserInfo>>(`${this.config.earthUrl}/api/usr/info`, {\n      context: new HttpContext().set(CACHEABLE_TOKEN, true)\n    });\n  }\n\n  menus() {\n    return this.http.get<Result<Menu[]>>(`${this.config.earthUrl}/api/role-menus/${this.config.clientId}`, {\n      context: new HttpContext().set(CACHEABLE_TOKEN, true)\n    }).pipe(\n      filterResult(),\n      map(({ data }) => normalizeMenus(data))\n    );\n  }\n\n  /**\n   * 变更密码\n   * @param o\n   * @returns\n   */\n  changePassword(o: { oldPsw: string, newPsw: string }) {\n    return this.http.post<Result>(`${this.config.earthUrl}/api/user/psw`, o).pipe(\n      tap(({ code }) => {\n        if (code === 0) {\n          this.cacheManager.revokeAll();\n        }\n      })\n    );\n  }\n\n  channels(origin: Origin) {\n    return this.http.get<Result<Channel[]>>(`${this.config.earthUrl}/api/channel/${origin}`, {\n      context: new HttpContext().set(CACHEABLE_TOKEN, true)\n    });\n  }\n\n  categories(origin: Origin) {\n    return this.http.get<Result<Category[]>>(`${this.config.earthUrl}/api/category/${origin}`, {\n      context: new HttpContext().set(CACHEABLE_TOKEN, true)\n    });\n  }\n\n  address(pid?: number) {\n    return this.http.get<Result<Address[]>>(`${this.config.earthUrl}/api/addrs`, {\n      params: pid ? { pid } : undefined,\n      context: new HttpContext().set(CACHEABLE_TOKEN, true)\n    });\n  }\n\n  avatarUploadKey() {\n    return this.http.get<Result<UploadKeys>>(`${this.config.earthUrl}/api/qiniu/avatar/upload-key`);\n  }\n\n  mediaUploadKeys(keySize = 1) {\n    return this.http.get<Result<UploadKeys>>(`${this.config.earthUrl}/api/qiniu/media/upload-keys`, {\n      params: { keySize }\n    });\n  }\n}\n"]}

package/esm2022/earth/guards/auth.guard.mjs

@@ -0,0 +1,30 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { map } from 'rxjs';
+import { EarthService } from '../earth.service';
+/**
+ * 认证路由守卫
+ * 认证后才允许进入，否则将导航到登录页（/login）
+ * @param options
+ */
+export function authMatchGuard(options) {
+    return (_route, segments) => {
+        const router = inject(Router);
+        const earthService = inject(EarthService);
+        const redirectUrl = {
+            redirect: router.createUrlTree(['/' + segments.join('/')], {
+                queryParams: Object.fromEntries(new URLSearchParams(location.search))
+            }).toString()
+        };
+        return earthService.checkAuth().pipe(map(bool => {
+            if (!bool) {
+                return router.createUrlTree([
+                    '/login',
+                    options?.redirect === undefined || options.redirect ? redirectUrl : {}
+                ]);
+            }
+            return bool;
+        }));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/earth/guards/index.mjs

@@ -0,0 +1,4 @@
+export * from './auth.guard';
+export * from './permission.guard';
+export * from './unauth.guard';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wbGFuZXRzL2VhcnRoL2d1YXJkcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F1dGguZ3VhcmQnO1xuZXhwb3J0ICogZnJvbSAnLi9wZXJtaXNzaW9uLmd1YXJkJztcbmV4cG9ydCAqIGZyb20gJy4vdW5hdXRoLmd1YXJkJztcbiJdfQ==

package/esm2022/earth/guards/permission.guard.mjs

@@ -0,0 +1,16 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { map } from 'rxjs';
+import { EarthService } from '../earth.service';
+/**
+ * 权限路由守卫
+ * 有权限才允许进入，否则导航到无权限页（/forbidden）
+ */
+export function permissionMatchGuard() {
+    return (_route, segments) => {
+        const router = inject(Router);
+        const earthService = inject(EarthService);
+        return earthService.checkPermission(segments).pipe(map(bool => bool || router.parseUrl('/forbidden')));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbi5ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3BsYW5ldHMvZWFydGgvZ3VhcmRzL3Blcm1pc3Npb24uZ3VhcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQXFCLE1BQU0sRUFBdUIsTUFBTSxpQkFBaUIsQ0FBQztBQUNqRixPQUFPLEVBQWMsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVoRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsb0JBQW9CO0lBQ2xDLE9BQU8sQ0FBQyxNQUFhLEVBQUUsUUFBc0IsRUFBa0YsRUFBRTtRQUMvSCxNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDOUIsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBRTFDLE9BQU8sWUFBWSxDQUFDLGVBQWUsQ0FBQyxRQUFRLENBQUMsQ0FBQyxJQUFJLENBQ2hELEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUNULElBQUksSUFBSSxNQUFNLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQyxDQUN0QyxDQUNGLENBQUM7SUFDSixDQUFDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDYW5NYXRjaEZuLCBSb3V0ZSwgUm91dGVyLCBVcmxTZWdtZW50LCBVcmxUcmVlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IE9ic2VydmFibGUsIG1hcCB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgRWFydGhTZXJ2aWNlIH0gZnJvbSAnLi4vZWFydGguc2VydmljZSc7XG5cbi8qKlxuICog5p2D6ZmQ6Lev55Sx5a6I5Y2rXG4gKiDmnInmnYPpmZDmiY3lhYHorrjov5vlhaXvvIzlkKbliJnlr7zoiKrliLDml6DmnYPpmZDpobXvvIgvZm9yYmlkZGVu77yJXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwZXJtaXNzaW9uTWF0Y2hHdWFyZCgpOiBDYW5NYXRjaEZuIHtcbiAgcmV0dXJuIChfcm91dGU6IFJvdXRlLCBzZWdtZW50czogVXJsU2VnbWVudFtdKTogT2JzZXJ2YWJsZTxib29sZWFuIHwgVXJsVHJlZT4gfCBQcm9taXNlPGJvb2xlYW4gfCBVcmxUcmVlPiB8IGJvb2xlYW4gfCBVcmxUcmVlID0+IHtcbiAgICBjb25zdCByb3V0ZXIgPSBpbmplY3QoUm91dGVyKTtcbiAgICBjb25zdCBlYXJ0aFNlcnZpY2UgPSBpbmplY3QoRWFydGhTZXJ2aWNlKTtcblxuICAgIHJldHVybiBlYXJ0aFNlcnZpY2UuY2hlY2tQZXJtaXNzaW9uKHNlZ21lbnRzKS5waXBlKFxuICAgICAgbWFwKGJvb2wgPT5cbiAgICAgICAgYm9vbCB8fCByb3V0ZXIucGFyc2VVcmwoJy9mb3JiaWRkZW4nKVxuICAgICAgKVxuICAgICk7XG4gIH07XG59XG4iXX0=

package/esm2022/earth/guards/unauth.guard.mjs

@@ -0,0 +1,16 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { map } from 'rxjs';
+import { EarthService } from '../earth.service';
+/**
+ * 未认证路由守卫
+ * 未认证才允许进入，否则将导航到首页
+ */
+export function unauthMatchGuard() {
+    return (_route, _segments) => {
+        const router = inject(Router);
+        const earthService = inject(EarthService);
+        return earthService.checkAuth().pipe(map(bool => bool ? router.parseUrl('/') : true));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5hdXRoLmd1YXJkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcGxhbmV0cy9lYXJ0aC9ndWFyZHMvdW5hdXRoLmd1YXJkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFxQixNQUFNLEVBQXVCLE1BQU0saUJBQWlCLENBQUM7QUFDakYsT0FBTyxFQUFjLEdBQUcsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUN2QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLGdCQUFnQjtJQUM5QixPQUFPLENBQUMsTUFBYSxFQUFFLFNBQXVCLEVBQWtGLEVBQUU7UUFDaEksTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQzlCLE1BQU0sWUFBWSxHQUFHLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUUxQyxPQUFPLFlBQVksQ0FBQyxTQUFTLEVBQUUsQ0FBQyxJQUFJLENBQ2xDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQ2hELENBQUM7SUFDSixDQUFDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDYW5NYXRjaEZuLCBSb3V0ZSwgUm91dGVyLCBVcmxTZWdtZW50LCBVcmxUcmVlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IE9ic2VydmFibGUsIG1hcCB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgRWFydGhTZXJ2aWNlIH0gZnJvbSAnLi4vZWFydGguc2VydmljZSc7XG5cbi8qKlxuICog5pyq6K6k6K+B6Lev55Sx5a6I5Y2rXG4gKiDmnKrorqTor4HmiY3lhYHorrjov5vlhaXvvIzlkKbliJnlsIblr7zoiKrliLDpppbpobVcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHVuYXV0aE1hdGNoR3VhcmQoKTogQ2FuTWF0Y2hGbiB7XG4gIHJldHVybiAoX3JvdXRlOiBSb3V0ZSwgX3NlZ21lbnRzOiBVcmxTZWdtZW50W10pOiBPYnNlcnZhYmxlPGJvb2xlYW4gfCBVcmxUcmVlPiB8IFByb21pc2U8Ym9vbGVhbiB8IFVybFRyZWU+IHwgYm9vbGVhbiB8IFVybFRyZWUgPT4ge1xuICAgIGNvbnN0IHJvdXRlciA9IGluamVjdChSb3V0ZXIpO1xuICAgIGNvbnN0IGVhcnRoU2VydmljZSA9IGluamVjdChFYXJ0aFNlcnZpY2UpO1xuXG4gICAgcmV0dXJuIGVhcnRoU2VydmljZS5jaGVja0F1dGgoKS5waXBlKFxuICAgICAgbWFwKGJvb2wgPT4gYm9vbCA/IHJvdXRlci5wYXJzZVVybCgnLycpIDogdHJ1ZSksXG4gICAgKTtcbiAgfTtcbn1cbiJdfQ==

package/esm2022/earth/index.mjs

@@ -0,0 +1,7 @@
+export * from './earth.pipe';
+export * from './earth.resolver';
+export * from './earth.service';
+export * from './guards';
+export * from './menu.service';
+export * from './object-storage.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wbGFuZXRzL2VhcnRoL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2VhcnRoLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9lYXJ0aC5yZXNvbHZlcic7XG5leHBvcnQgKiBmcm9tICcuL2VhcnRoLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ndWFyZHMnO1xuZXhwb3J0ICogZnJvbSAnLi9tZW51LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9vYmplY3Qtc3RvcmFnZS5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/earth/menu.service.mjs

@@ -0,0 +1,37 @@
+import { inject, Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { map } from 'rxjs';
+import { EarthService } from './earth.service';
+import * as i0 from "@angular/core";
+export class MenuService {
+    constructor() {
+        this.earthService = inject(EarthService);
+        this.router = inject(Router);
+        /**
+         * 当前的菜单数组
+         */
+        this.menus$ = this.earthService.menus().pipe(map(data => {
+            const menus = [];
+            const url = this.pureUrl;
+            let end = data.find(o => o.url === url);
+            while (end) {
+                menus.unshift(end);
+                end = end.parent;
+            }
+            return menus;
+        }));
+    }
+    get pureUrl() {
+        // 只取最后一段 /m/staff;a=b?c=d => staff
+        return this.router.url.replace(/(^.+\/)|((;|\?).+$)/g, '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/earth/object-storage.service.mjs

@@ -0,0 +1,44 @@
+import { HttpClient, HttpContext } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { API_TOKEN } from '@solar-angular/http';
+import * as i0 from "@angular/core";
+export class ObjectStorageService {
+    constructor() {
+        this.http = inject(HttpClient);
+    }
+    /**
+     * 目前只支持了 qiniu oss
+     * @param filePath
+     * @param options
+     * @returns
+     */
+    upload(file, key, options) {
+        const formData = new FormData();
+        formData.set('key', key);
+        formData.set('file', file);
+        formData.set('token', options.token);
+        return this.http.post(`https://${options.host}`, formData, {
+            context: new HttpContext().set(API_TOKEN, false)
+        });
+    }
+    uploadWithEvents(file, key, options) {
+        const formData = new FormData();
+        formData.set('key', key);
+        formData.set('file', file);
+        formData.set('token', options.token);
+        return this.http.post(`https://${options.host}`, formData, {
+            context: new HttpContext().set(API_TOKEN, false),
+            observe: 'events',
+            reportProgress: true,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/earth/solar-angular-planets-earth.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29sYXItYW5ndWxhci1wbGFuZXRzLWVhcnRoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvcGxhbmV0cy9lYXJ0aC9zb2xhci1hbmd1bGFyLXBsYW5ldHMtZWFydGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/index.mjs

@@ -0,0 +1,2 @@
+export default void 0;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wYWNrYWdlcy9wbGFuZXRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsS0FBSyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCB2b2lkIDA7XG4iXX0=