vona-module-a-static 5.0.9 → 5.0.10

package/dist/.metadata/index.d.ts

@@ -0,0 +1,58 @@
+import type { BeanScopeUtil } from 'vona';
+import type { EventOn } from 'vona-module-a-event';
+/** event: end */
+/** event: begin */
+import type { EventResolvePath } from '../bean/event.resolvePath.ts';
+/** event: end */
+/** event: begin */
+import type { TypeEventResolvePathData, TypeEventResolvePathResult } from '../bean/event.resolvePath.ts';
+/** middlewareSystem: end */
+/** event: begin */
+import type { IMiddlewareSystemOptionsStatic } from '../bean/middlewareSystem.static.ts';
+/** event: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from '../bean/event.resolvePath.ts';
+declare module 'vona-module-a-aspect' {
+    interface IMiddlewareSystemRecord {
+        'a-static:static': IMiddlewareSystemOptionsStatic;
+    }
+}
+declare module 'vona-module-a-static' {
+    interface MiddlewareSystemStatic {
+    }
+}
+/** middlewareSystem: begin */
+export * from '../bean/middlewareSystem.static.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-a-static' {
+    interface EventResolvePath {
+    }
+}
+export interface IModuleEvent {
+    resolvePath: EventResolvePath;
+}
+declare module 'vona-module-a-event' {
+    interface IEventRecord {
+        'a-static:resolvePath': EventOn<TypeEventResolvePathData, TypeEventResolvePathResult>;
+    }
+}
+export declare class ScopeModuleAStatic extends BeanScopeBase {
+}
+export interface ScopeModuleAStatic {
+    util: BeanScopeUtil;
+    event: IModuleEvent;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-static': ScopeModuleAStatic;
+    }
+    interface IBeanScopeContainer {
+        static: ScopeModuleAStatic;
+    }
+}
+/** scope: end */

package/dist/.metadata/index.js

@@ -0,0 +1,23 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/** event: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from "../bean/event.resolvePath.js";
+/** middlewareSystem: begin */
+export * from "../bean/middlewareSystem.static.js";
+let ScopeModuleAStatic = class ScopeModuleAStatic extends BeanScopeBase {
+};
+ScopeModuleAStatic = __decorate([
+    Scope()
+], ScopeModuleAStatic);
+export { ScopeModuleAStatic };
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-static";
+export { ScopeModuleAStatic as ScopeModule } from './index.ts';

package/dist/.metadata/this.js

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'a-static';
+export { ScopeModuleAStatic as ScopeModule } from "./index.js";

package/dist/bean/event.resolvePath.d.ts

@@ -0,0 +1,10 @@
+import type { IMiddlewareSystemOptionsStatic } from './middlewareSystem.static.ts';
+import { BeanEventBase } from 'vona-module-a-event';
+export interface TypeEventResolvePathData {
+    dir: string;
+    filename: string;
+    options: IMiddlewareSystemOptionsStatic;
+}
+export type TypeEventResolvePathResult = string | true | undefined;
+export declare class EventResolvePath extends BeanEventBase<TypeEventResolvePathData, TypeEventResolvePathResult> {
+}

package/dist/bean/event.resolvePath.js

@@ -0,0 +1,13 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BeanEventBase, Event } from 'vona-module-a-event';
+let EventResolvePath = class EventResolvePath extends BeanEventBase {
+};
+EventResolvePath = __decorate([
+    Event()
+], EventResolvePath);
+export { EventResolvePath };

package/dist/bean/middlewareSystem.static.d.ts

@@ -0,0 +1,27 @@
+import type { Next, VonaContext } from 'vona';
+import type { IDecoratorMiddlewareSystemOptions, IMiddlewareSystemExecute } from 'vona-module-a-aspect';
+import { BeanBase } from 'vona';
+interface IStaticDirItem {
+    prefix: string;
+    dir: string;
+}
+export interface IMiddlewareSystemOptionsStatic extends IDecoratorMiddlewareSystemOptions {
+    apiStaticPrefix: string;
+    dir?: string;
+    dirs: (string | IStaticDirItem)[];
+    dynamic: boolean;
+    preload: boolean;
+    buffer?: boolean;
+    maxFiles: number;
+    maxAge?: number;
+    alias: Record<string, string>;
+    getFullPath: typeof getFullPath;
+}
+export declare class MiddlewareSystemStatic extends BeanBase implements IMiddlewareSystemExecute {
+    private _composer;
+    execute(options: IMiddlewareSystemOptionsStatic, next: Next): Promise<any>;
+    _getComposer(options: IMiddlewareSystemOptionsStatic): any;
+    _createMiddlewares(options: IMiddlewareSystemOptionsStatic): ((ctx: any, next: any) => any)[];
+}
+declare function getFullPath(ctx: VonaContext, dir: string, filename: string, options: IMiddlewareSystemOptionsStatic): Promise<string | true | undefined>;
+export {};

package/dist/bean/middlewareSystem.static.js

@@ -0,0 +1,130 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import assert from 'node:assert';
+import { existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import staticCache from '@cabloy/koa-static-cache';
+import { isObject, isString } from '@cabloy/utils';
+import range from 'koa-range';
+import { BeanBase, compose } from 'vona';
+import { MiddlewareSystem } from 'vona-module-a-aspect';
+import { LRU } from 'ylru';
+import { __ThisModule__ } from "../.metadata/this.js";
+import { SymbolStaticGetFullPathInner } from "../types/static.js";
+let MiddlewareSystemStatic = class MiddlewareSystemStatic extends BeanBase {
+    _composer;
+    async execute(options, next) {
+        return this._getComposer(options)(this.ctx, next);
+    }
+    _getComposer(options) {
+        if (!this._composer) {
+            const middlewares = this._createMiddlewares(options);
+            this._composer = compose(middlewares);
+        }
+        return this._composer;
+    }
+    _createMiddlewares(options) {
+        options = Object.assign({
+            maxAge: this.app.meta.isProd ? 31536000 : 0,
+            buffer: !!this.app.meta.isProd,
+            dir: this.app.config.server.publicDir,
+            prefix: '/',
+        }, options);
+        const dirs = (options.dirs || []).concat(options.dir);
+        const prefixs = [];
+        function rangeMiddleware(ctx, next) {
+            // if match static file, and use range middleware.
+            const isMatch = prefixs.some(p => ctx.path.startsWith(p));
+            if (isMatch) {
+                return range(ctx, next);
+            }
+            return next();
+        }
+        const middlewares = [rangeMiddleware];
+        for (const dirObj of dirs) {
+            assert(isObject(dirObj) || isString(dirObj), '`config.static.dir` must be `string | Array<string|object>`.');
+            let newOptions;
+            if (isString(dirObj)) {
+                // copy origin options to new options ensure the safety of objects
+                newOptions = Object.assign({}, options, { dir: dirObj });
+            }
+            else {
+                assert(isString(dirObj.dir), '`config.static.dir` should contains `[].dir` property when object style.');
+                newOptions = Object.assign({}, options, dirObj);
+            }
+            if (newOptions.dynamic && !newOptions.files) {
+                newOptions.files = new LRU(newOptions.maxFiles);
+            }
+            if (newOptions.prefix) {
+                prefixs.push(newOptions.prefix);
+            }
+            // ensure directory exists
+            if (!existsSync(newOptions.dir)) {
+                mkdirSync(newOptions.dir, { recursive: true });
+            }
+            middlewares.push(staticCache(newOptions));
+        }
+        return middlewares;
+    }
+};
+MiddlewareSystemStatic = __decorate([
+    MiddlewareSystem({
+        dependencies: 'a-instance:appReady',
+        apiStaticPrefix: '/api/static/',
+        dirs: [],
+        dynamic: true,
+        preload: false,
+        maxFiles: 1000,
+        alias: {
+            '/favicon.ico': '/api/static/home/index/img/vona.png',
+        },
+        getFullPath,
+        // maxAge: undefined,
+        // buffer: false,
+        // dir: '',
+        // prefix: '/', // should be always '/', so as to support ssr site
+    })
+], MiddlewareSystemStatic);
+export { MiddlewareSystemStatic };
+async function getFullPath(ctx, dir, filename, options) {
+    if (process.env.META_MODE === 'local') {
+        ctx[SymbolStaticGetFullPathInner] = () => {
+            return _getFullPathInner(ctx, dir, filename, options);
+        };
+    }
+    const scopeSelf = ctx.app.bean.scope(__ThisModule__);
+    return scopeSelf.event.resolvePath.emit({ dir, filename, options }, ({ dir, filename, options }) => {
+        return _getFullPathInner(ctx, dir, filename, options);
+    });
+}
+async function _getFullPathInner(ctx, dir, filename, options) {
+    // trim prefix
+    if (options.apiStaticPrefix !== '/') {
+        const filePrefix = path.normalize(options.apiStaticPrefix.replace(/^\//, ''));
+        if (filename.indexOf(filePrefix) !== 0)
+            return;
+        filename = filename.slice(filePrefix.length);
+    }
+    // check
+    const parts = filename.split(path.sep);
+    const wordFirst = parts.shift();
+    // public
+    if (wordFirst === 'public') {
+        const fullPath = path.normalize(path.join(dir, parts.join(path.sep)));
+        // files that can be accessd should be under options.dir
+        if (fullPath.indexOf(dir) !== 0)
+            return;
+        return fullPath;
+    }
+    // static
+    const moduleRelativeName = `${wordFirst}-${parts.shift()}`;
+    const module = ctx.app.meta.modules[moduleRelativeName];
+    if (!module)
+        return;
+    const fullPath = ctx.app.util.getAssetPathPhysical(moduleRelativeName, 'static', parts.join(path.sep));
+    return fullPath;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './.metadata/index.ts';
+export * from './lib/index.ts';
+export * from './types/index.ts';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./.metadata/index.js";
+export * from "./lib/index.js";
+export * from "./types/index.js";

package/dist/lib/beanStaticBase.d.ts

@@ -0,0 +1,4 @@
+import { BeanBase } from 'vona';
+export declare class BeanStaticBase extends BeanBase {
+    protected __get__(prop: string): ((path: string) => string) | undefined;
+}

package/dist/lib/beanStaticBase.js

@@ -0,0 +1,10 @@
+import { BeanBase, SymbolModuleBelong } from 'vona';
+export class BeanStaticBase extends BeanBase {
+    __get__(prop) {
+        if (prop === 'get') {
+            return (path) => {
+                return this.app.util.combineStaticPath(path, this[SymbolModuleBelong]);
+            };
+        }
+    }
+}

package/dist/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './beanStaticBase.ts';

package/dist/lib/index.js

@@ -0,0 +1 @@
+export * from "./beanStaticBase.js";

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './static.ts';

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from "./static.js";

package/dist/types/static.d.ts

@@ -0,0 +1 @@
+export declare const SymbolStaticGetFullPathInner: unique symbol;

package/dist/types/static.js

@@ -0,0 +1 @@
+export const SymbolStaticGetFullPathInner = Symbol('SymbolStaticGetFullPathInner');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-static",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.10",
   "title": "a-static",
   "vonaModule": {
     "dependencies": {},
@@ -37,8 +37,12 @@
     "koa-range": "^0.3.0",
     "ylru": "^2.0.0"
   },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
   "scripts": {
-    "clean": "rimraf dist tsconfig.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc"
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && tsc -p tsconfig.build.json"
   }
 }