vona-module-a-static 5.0.9 → 5.0.11

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/this.d.ts

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

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/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/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,164 @@
+import { BeanInfo, BeanBase, compose, BeanScopeBase, SymbolModuleBelong } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+import { Event, BeanEventBase } from 'vona-module-a-event';
+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 { MiddlewareSystem } from 'vona-module-a-aspect';
+import { LRU } from 'ylru';
+
+var _dec$2, _dec2$2, _class$2;
+let EventResolvePath = (_dec$2 = Event(), _dec2$2 = BeanInfo({
+  module: "a-static"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = class EventResolvePath extends BeanEventBase {}) || _class$2) || _class$2);
+
+const __ThisModule__ = 'a-static';
+
+const SymbolStaticGetFullPathInner = Symbol('SymbolStaticGetFullPathInner');
+
+var _dec$1, _dec2$1, _class$1;
+let MiddlewareSystemStatic = (_dec$1 = 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
+}), _dec2$1 = BeanInfo({
+  module: "a-static"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class MiddlewareSystemStatic extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._composer = void 0;
+  }
+  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;
+  }
+}) || _class$1) || _class$1);
+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;
+}
+
+var _dec, _dec2, _class;
+let ScopeModuleAStatic = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-static"
+}), _dec(_class = _dec2(_class = class ScopeModuleAStatic extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+class BeanStaticBase extends BeanBase {
+  __get__(prop) {
+    if (prop === 'get') {
+      return path => {
+        return this.app.util.combineStaticPath(path, this[SymbolModuleBelong]);
+      };
+    }
+  }
+}
+
+export { BeanStaticBase, EventResolvePath, MiddlewareSystemStatic, ScopeModuleAStatic, SymbolStaticGetFullPathInner };

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/index.d.ts

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

package/dist/types/index.d.ts

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

package/dist/types/static.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-static",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.11",
   "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 && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }