@eggjs/view 4.0.0-beta.18 → 4.0.0-beta.20

package/dist/app/extend/application.d.ts

@@ -1,15 +1,4 @@
-import { ViewManager } from "../../lib/view_manager.js";
-import { Application } from "egg";
-
-//#region src/app/extend/application.d.ts
-declare const VIEW: unique symbol;
-declare class ViewApplication extends Application {
-  [VIEW]: ViewManager;
-  /**
-   * Retrieve ViewManager instance
-   * @member {ViewManager} Application#view
-   */
-  get view(): ViewManager;
-}
-//#endregion
+import "../../config.default-BgQBnsOY.js";
+import "../../view_manager-c9xtBmJn.js";
+import { ViewApplication } from "../../application-Bd506fKt.js";
 export { ViewApplication as default };

package/dist/app/extend/application.js

@@ -1,19 +1,4 @@
-import { ViewManager } from "../../lib/view_manager.js";
-import { Application } from "egg";
+import "../../view_manager-D6jOE8_P.js";
+import { ViewApplication } from "../../application-CnXv9dB0.js";
 
-//#region src/app/extend/application.ts
-const VIEW = Symbol("Application#view");
-var ViewApplication = class extends Application {
-	[VIEW];
-	/**
-	* Retrieve ViewManager instance
-	* @member {ViewManager} Application#view
-	*/
-	get view() {
-		if (!this[VIEW]) this[VIEW] = new ViewManager(this);
-		return this[VIEW];
-	}
-};
-
-//#endregion
 export { ViewApplication as default };

package/dist/app/extend/context.d.ts

@@ -1,39 +1,5 @@
-import { RenderOptions } from "../../lib/view_manager.js";
-import { ContextView } from "../../lib/context_view.js";
-import { Context } from "egg";
-
-//#region src/app/extend/context.d.ts
-declare const VIEW: unique symbol;
-declare class ViewContext extends Context {
-  [VIEW]: ContextView;
-  /**
-   * Render a file by view engine, then set to body
-   * @param {String} name - the file path based on root
-   * @param {Object} [locals] - data used by template
-   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-   */
-  render(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<void>;
-  /**
-   * Render a file by view engine and return it
-   * @param {String} name - the file path based on root
-   * @param {Object} [locals] - data used by template
-   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-   * @return {Promise<String>} result - return a promise with a render result
-   */
-  renderView(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
-  /**
-   * Render template string by view engine and return it
-   * @param {String} tpl - template string
-   * @param {Object} [locals] - data used by template
-   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-   * @return {Promise<String>} result - return a promise with a render result
-   */
-  renderString(tpl: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
-  /**
-   * View instance that is created every request
-   * @member {ContextView} Context#view
-   */
-  get view(): ContextView;
-}
-//#endregion
+import "../../config.default-BgQBnsOY.js";
+import "../../view_manager-c9xtBmJn.js";
+import "../../context_view-FFsbwt3g.js";
+import { ViewContext } from "../../context-admUp9Fl.js";
 export { ViewContext as default };

package/dist/app/extend/context.js

@@ -1,49 +1,5 @@
-import "../../lib/view_manager.js";
-import { ContextView } from "../../lib/context_view.js";
-import { Context } from "egg";
+import "../../view_manager-D6jOE8_P.js";
+import "../../context_view-CalYICWU.js";
+import { ViewContext } from "../../context-4Ct-3wiQ.js";
 
-//#region src/app/extend/context.ts
-const VIEW = Symbol("Context#view");
-var ViewContext = class extends Context {
-	[VIEW];
-	/**
-	* Render a file by view engine, then set to body
-	* @param {String} name - the file path based on root
-	* @param {Object} [locals] - data used by template
-	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-	*/
-	async render(name, locals, options) {
-		this.body = await this.renderView(name, locals, options);
-	}
-	/**
-	* Render a file by view engine and return it
-	* @param {String} name - the file path based on root
-	* @param {Object} [locals] - data used by template
-	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-	* @return {Promise<String>} result - return a promise with a render result
-	*/
-	async renderView(name, locals, options) {
-		return await this.view.render(name, locals, options);
-	}
-	/**
-	* Render template string by view engine and return it
-	* @param {String} tpl - template string
-	* @param {Object} [locals] - data used by template
-	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-	* @return {Promise<String>} result - return a promise with a render result
-	*/
-	async renderString(tpl, locals, options) {
-		return await this.view.renderString(tpl, locals, options);
-	}
-	/**
-	* View instance that is created every request
-	* @member {ContextView} Context#view
-	*/
-	get view() {
-		if (!this[VIEW]) this[VIEW] = new ContextView(this);
-		return this[VIEW];
-	}
-};
-
-//#endregion
 export { ViewContext as default };

package/dist/application-Bd506fKt.d.ts

@@ -0,0 +1,15 @@
+import { ViewManager } from "./view_manager-c9xtBmJn.js";
+import { Application } from "egg";
+
+//#region src/app/extend/application.d.ts
+declare const VIEW: unique symbol;
+declare class ViewApplication extends Application {
+  [VIEW]: ViewManager;
+  /**
+   * Retrieve ViewManager instance
+   * @member {ViewManager} Application#view
+   */
+  get view(): ViewManager;
+}
+//#endregion
+export { ViewApplication };

package/dist/application-CnXv9dB0.js

@@ -0,0 +1,19 @@
+import { ViewManager } from "./view_manager-D6jOE8_P.js";
+import { Application } from "egg";
+
+//#region src/app/extend/application.ts
+const VIEW = Symbol("Application#view");
+var ViewApplication = class extends Application {
+	[VIEW];
+	/**
+	* Retrieve ViewManager instance
+	* @member {ViewManager} Application#view
+	*/
+	get view() {
+		if (!this[VIEW]) this[VIEW] = new ViewManager(this);
+		return this[VIEW];
+	}
+};
+
+//#endregion
+export { ViewApplication };

package/dist/config/config.default.d.ts

@@ -1,33 +1,2 @@
-import * as egg1 from "egg";
-
-//#region src/config/config.default.d.ts
-interface ViewConfig {
-  /**
-   * give a path to find the file, you can specify multiple path with `,` delimiter
-   * Default is `${baseDir}/app/view`
-   */
-  root: string;
-  /**
-   * whether cache the file's path
-   * Default is `true`
-   */
-  cache: boolean;
-  /**
-   * defaultExtension can be added automatically when there is no extension  when call `ctx.render`
-   * Default is `.html`
-   */
-  defaultExtension: string;
-  /**
-   * set the default view engine if you don't want specify the viewEngine every request.
-   * Default is `''`
-   */
-  defaultViewEngine: string;
-  /**
-   * map the file extension to view engine, such as `{ '.ejs': 'ejs' }`
-   * Default is `{}`
-   */
-  mapping: Record<string, string>;
-}
-declare const _default: egg1.EggConfigFactory;
-//#endregion
+import { ViewConfig, _default } from "../config.default-BgQBnsOY.js";
 export { ViewConfig, _default as default };

package/dist/config/config.default.js

@@ -1,14 +1,3 @@
-import path from "node:path";
-import { defineConfigFactory } from "egg";
+import { config_default_default } from "../config.default-k-ZZJzwc.js";
 
-//#region src/config/config.default.ts
-var config_default_default = defineConfigFactory((appInfo) => ({ view: {
-	root: path.join(appInfo.baseDir, "app/view"),
-	cache: true,
-	defaultExtension: ".html",
-	defaultViewEngine: "",
-	mapping: {}
-} }));
-
-//#endregion
 export { config_default_default as default };

package/dist/config.default-BgQBnsOY.d.ts

@@ -0,0 +1,33 @@
+import * as egg0 from "egg";
+
+//#region src/config/config.default.d.ts
+interface ViewConfig {
+  /**
+   * give a path to find the file, you can specify multiple path with `,` delimiter
+   * Default is `${baseDir}/app/view`
+   */
+  root: string;
+  /**
+   * whether cache the file's path
+   * Default is `true`
+   */
+  cache: boolean;
+  /**
+   * defaultExtension can be added automatically when there is no extension  when call `ctx.render`
+   * Default is `.html`
+   */
+  defaultExtension: string;
+  /**
+   * set the default view engine if you don't want specify the viewEngine every request.
+   * Default is `''`
+   */
+  defaultViewEngine: string;
+  /**
+   * map the file extension to view engine, such as `{ '.ejs': 'ejs' }`
+   * Default is `{}`
+   */
+  mapping: Record<string, string>;
+}
+declare const _default: egg0.EggConfigFactory;
+//#endregion
+export { ViewConfig, _default };

package/dist/config.default-k-ZZJzwc.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+import { defineConfigFactory } from "egg";
+
+//#region src/config/config.default.ts
+var config_default_default = defineConfigFactory((appInfo) => ({ view: {
+	root: path.join(appInfo.baseDir, "app/view"),
+	cache: true,
+	defaultExtension: ".html",
+	defaultViewEngine: "",
+	mapping: {}
+} }));
+
+//#endregion
+export { config_default_default };

package/dist/context-4Ct-3wiQ.js

@@ -0,0 +1,48 @@
+import { ContextView } from "./context_view-CalYICWU.js";
+import { Context } from "egg";
+
+//#region src/app/extend/context.ts
+const VIEW = Symbol("Context#view");
+var ViewContext = class extends Context {
+	[VIEW];
+	/**
+	* Render a file by view engine, then set to body
+	* @param {String} name - the file path based on root
+	* @param {Object} [locals] - data used by template
+	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+	*/
+	async render(name, locals, options) {
+		this.body = await this.renderView(name, locals, options);
+	}
+	/**
+	* Render a file by view engine and return it
+	* @param {String} name - the file path based on root
+	* @param {Object} [locals] - data used by template
+	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+	* @return {Promise<String>} result - return a promise with a render result
+	*/
+	async renderView(name, locals, options) {
+		return await this.view.render(name, locals, options);
+	}
+	/**
+	* Render template string by view engine and return it
+	* @param {String} tpl - template string
+	* @param {Object} [locals] - data used by template
+	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+	* @return {Promise<String>} result - return a promise with a render result
+	*/
+	async renderString(tpl, locals, options) {
+		return await this.view.renderString(tpl, locals, options);
+	}
+	/**
+	* View instance that is created every request
+	* @member {ContextView} Context#view
+	*/
+	get view() {
+		if (!this[VIEW]) this[VIEW] = new ContextView(this);
+		return this[VIEW];
+	}
+};
+
+//#endregion
+export { ViewContext };

package/dist/context-admUp9Fl.d.ts

@@ -0,0 +1,39 @@
+import { RenderOptions } from "./view_manager-c9xtBmJn.js";
+import { ContextView } from "./context_view-FFsbwt3g.js";
+import { Context } from "egg";
+
+//#region src/app/extend/context.d.ts
+declare const VIEW: unique symbol;
+declare class ViewContext extends Context {
+  [VIEW]: ContextView;
+  /**
+   * Render a file by view engine, then set to body
+   * @param {String} name - the file path based on root
+   * @param {Object} [locals] - data used by template
+   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+   */
+  render(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<void>;
+  /**
+   * Render a file by view engine and return it
+   * @param {String} name - the file path based on root
+   * @param {Object} [locals] - data used by template
+   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+   * @return {Promise<String>} result - return a promise with a render result
+   */
+  renderView(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
+  /**
+   * Render template string by view engine and return it
+   * @param {String} tpl - template string
+   * @param {Object} [locals] - data used by template
+   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+   * @return {Promise<String>} result - return a promise with a render result
+   */
+  renderString(tpl: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
+  /**
+   * View instance that is created every request
+   * @member {ContextView} Context#view
+   */
+  get view(): ContextView;
+}
+//#endregion
+export { ViewContext };

package/dist/context_view-CalYICWU.js

@@ -0,0 +1,85 @@
+import path from "node:path";
+import assert from "node:assert";
+
+//#region src/lib/context_view.ts
+const RENDER = Symbol.for("contextView#render");
+const RENDER_STRING = Symbol.for("contextView#renderString");
+const GET_VIEW_ENGINE = Symbol.for("contextView#getViewEngine");
+const SET_LOCALS = Symbol.for("contextView#setLocals");
+/**
+* View instance for each request.
+*
+* It will find the view engine, and render it.
+* The view engine should be registered in {@link ViewManager}.
+*/
+var ContextView = class {
+	ctx;
+	app;
+	viewManager;
+	config;
+	constructor(ctx) {
+		this.ctx = ctx;
+		this.app = this.ctx.app;
+		this.viewManager = this.app.view;
+		this.config = this.app.view.config;
+	}
+	/**
+	* Render a file by view engine
+	* @param {String} name - the file path based on root
+	* @param {Object} [locals] - data used by template
+	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+	* @return {Promise<String>} result - return a promise with a render result
+	*/
+	async render(name, locals, options) {
+		return await this[RENDER](name, locals, options);
+	}
+	/**
+	* Render a template string by view engine
+	* @param {String} tpl - template string
+	* @param {Object} [locals] - data used by template
+	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+	* @return {Promise<String>} result - return a promise with a render result
+	*/
+	async renderString(tpl, locals, options) {
+		return await this[RENDER_STRING](tpl, locals, options);
+	}
+	async [RENDER](name, locals, options = {}) {
+		const filename = await this.viewManager.resolve(name);
+		options.name = name;
+		options.root = filename.replace(path.normalize(name), "").replace(/[/\\]$/, "");
+		options.locals = locals;
+		let viewEngineName = options.viewEngine;
+		if (!viewEngineName) {
+			const ext = path.extname(filename);
+			viewEngineName = this.viewManager.extMap.get(ext);
+		}
+		if (!viewEngineName) viewEngineName = this.config.defaultViewEngine;
+		assert(viewEngineName, `Can't find viewEngine for ${filename}`);
+		return await this[GET_VIEW_ENGINE](viewEngineName).render(filename, this[SET_LOCALS](locals), options);
+	}
+	async [RENDER_STRING](tpl, locals, options) {
+		let viewEngineName = options && options.viewEngine;
+		if (!viewEngineName) viewEngineName = this.config.defaultViewEngine;
+		assert(viewEngineName, "Can't find viewEngine");
+		return await this[GET_VIEW_ENGINE](viewEngineName).renderString(tpl, this[SET_LOCALS](locals), options);
+	}
+	[GET_VIEW_ENGINE](name) {
+		const ViewEngine = this.viewManager.get(name);
+		assert(ViewEngine, `Can't find ViewEngine "${name}"`);
+		return new ViewEngine(this.ctx);
+	}
+	/**
+	* set locals for view, inject `locals.ctx`, `locals.request`, `locals.helper`
+	* @private
+	*/
+	[SET_LOCALS](locals) {
+		return Object.assign({
+			ctx: this.ctx,
+			request: this.ctx.request,
+			helper: this.ctx.helper
+		}, this.ctx.locals, locals);
+	}
+};
+
+//#endregion
+export { ContextView };

package/dist/context_view-FFsbwt3g.d.ts

@@ -0,0 +1,52 @@
+import { RenderOptions, ViewEngine, ViewManager, ViewManagerConfig } from "./view_manager-c9xtBmJn.js";
+import * as egg0 from "egg";
+import { Application, Context } from "egg";
+
+//#region src/lib/context_view.d.ts
+declare const RENDER: unique symbol;
+declare const RENDER_STRING: unique symbol;
+declare const GET_VIEW_ENGINE: unique symbol;
+declare const SET_LOCALS: unique symbol;
+/**
+ * View instance for each request.
+ *
+ * It will find the view engine, and render it.
+ * The view engine should be registered in {@link ViewManager}.
+ */
+declare class ContextView {
+  protected ctx: Context;
+  protected app: Application;
+  protected viewManager: ViewManager;
+  protected config: ViewManagerConfig;
+  constructor(ctx: Context);
+  /**
+   * Render a file by view engine
+   * @param {String} name - the file path based on root
+   * @param {Object} [locals] - data used by template
+   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+   * @return {Promise<String>} result - return a promise with a render result
+   */
+  render(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
+  /**
+   * Render a template string by view engine
+   * @param {String} tpl - template string
+   * @param {Object} [locals] - data used by template
+   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
+   * @return {Promise<String>} result - return a promise with a render result
+   */
+  renderString(tpl: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
+  [RENDER](name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
+  [RENDER_STRING](tpl: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
+  [GET_VIEW_ENGINE](name: string): ViewEngine;
+  /**
+   * set locals for view, inject `locals.ctx`, `locals.request`, `locals.helper`
+   * @private
+   */
+  [SET_LOCALS](locals?: Record<string, any>): {
+    ctx: Context;
+    request: egg0.Request;
+    helper: egg0.Helper;
+  } & Record<string, any>;
+}
+//#endregion
+export { ContextView };

package/dist/index-CI4LJief.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/index.d.ts

@@ -1,3 +1,8 @@
-import { PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig } from "./lib/view_manager.js";
-import { ContextView } from "./lib/context_view.js";
+import "./config.default-BgQBnsOY.js";
+import { PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig } from "./view_manager-c9xtBmJn.js";
+import "./application-Bd506fKt.js";
+import { ContextView } from "./context_view-FFsbwt3g.js";
+import "./context-admUp9Fl.js";
+import "./types-4klwWQ8h.js";
+import "./index-CI4LJief.js";
 export { ContextView, PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig };

package/dist/index.js

@@ -1,8 +1,9 @@
-import "./config/config.default.js";
-import { ViewManager } from "./lib/view_manager.js";
-import "./app/extend/application.js";
-import { ContextView } from "./lib/context_view.js";
-import "./app/extend/context.js";
-import "./lib/index.js";
+import "./config.default-k-ZZJzwc.js";
+import { ViewManager } from "./view_manager-D6jOE8_P.js";
+import "./application-CnXv9dB0.js";
+import { ContextView } from "./context_view-CalYICWU.js";
+import "./context-4Ct-3wiQ.js";
+import "./types-BsuPrIpu.js";
+import "./lib-CKgd1dPu.js";
 
 export { ContextView, ViewManager };

package/dist/lib/context_view.d.ts

@@ -1,52 +1,4 @@
-import { RenderOptions, ViewEngine, ViewManager, ViewManagerConfig } from "./view_manager.js";
-import * as egg0 from "egg";
-import { Application, Context } from "egg";
-
-//#region src/lib/context_view.d.ts
-declare const RENDER: unique symbol;
-declare const RENDER_STRING: unique symbol;
-declare const GET_VIEW_ENGINE: unique symbol;
-declare const SET_LOCALS: unique symbol;
-/**
- * View instance for each request.
- *
- * It will find the view engine, and render it.
- * The view engine should be registered in {@link ViewManager}.
- */
-declare class ContextView {
-  protected ctx: Context;
-  protected app: Application;
-  protected viewManager: ViewManager;
-  protected config: ViewManagerConfig;
-  constructor(ctx: Context);
-  /**
-   * Render a file by view engine
-   * @param {String} name - the file path based on root
-   * @param {Object} [locals] - data used by template
-   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-   * @return {Promise<String>} result - return a promise with a render result
-   */
-  render(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
-  /**
-   * Render a template string by view engine
-   * @param {String} tpl - template string
-   * @param {Object} [locals] - data used by template
-   * @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-   * @return {Promise<String>} result - return a promise with a render result
-   */
-  renderString(tpl: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
-  [RENDER](name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
-  [RENDER_STRING](tpl: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
-  [GET_VIEW_ENGINE](name: string): ViewEngine;
-  /**
-   * set locals for view, inject `locals.ctx`, `locals.request`, `locals.helper`
-   * @private
-   */
-  [SET_LOCALS](locals?: Record<string, any>): {
-    ctx: Context;
-    request: egg0.Request;
-    helper: egg0.Helper;
-  } & Record<string, any>;
-}
-//#endregion
+import "../config.default-BgQBnsOY.js";
+import "../view_manager-c9xtBmJn.js";
+import { ContextView } from "../context_view-FFsbwt3g.js";
 export { ContextView };

package/dist/lib/context_view.js

@@ -1,86 +1,4 @@
-import "./view_manager.js";
-import path from "node:path";
-import assert from "node:assert";
+import "../view_manager-D6jOE8_P.js";
+import { ContextView } from "../context_view-CalYICWU.js";
 
-//#region src/lib/context_view.ts
-const RENDER = Symbol.for("contextView#render");
-const RENDER_STRING = Symbol.for("contextView#renderString");
-const GET_VIEW_ENGINE = Symbol.for("contextView#getViewEngine");
-const SET_LOCALS = Symbol.for("contextView#setLocals");
-/**
-* View instance for each request.
-*
-* It will find the view engine, and render it.
-* The view engine should be registered in {@link ViewManager}.
-*/
-var ContextView = class {
-	ctx;
-	app;
-	viewManager;
-	config;
-	constructor(ctx) {
-		this.ctx = ctx;
-		this.app = this.ctx.app;
-		this.viewManager = this.app.view;
-		this.config = this.app.view.config;
-	}
-	/**
-	* Render a file by view engine
-	* @param {String} name - the file path based on root
-	* @param {Object} [locals] - data used by template
-	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-	* @return {Promise<String>} result - return a promise with a render result
-	*/
-	async render(name, locals, options) {
-		return await this[RENDER](name, locals, options);
-	}
-	/**
-	* Render a template string by view engine
-	* @param {String} tpl - template string
-	* @param {Object} [locals] - data used by template
-	* @param {Object} [options] - view options, you can use `options.viewEngine` to specify view engine
-	* @return {Promise<String>} result - return a promise with a render result
-	*/
-	async renderString(tpl, locals, options) {
-		return await this[RENDER_STRING](tpl, locals, options);
-	}
-	async [RENDER](name, locals, options = {}) {
-		const filename = await this.viewManager.resolve(name);
-		options.name = name;
-		options.root = filename.replace(path.normalize(name), "").replace(/[/\\]$/, "");
-		options.locals = locals;
-		let viewEngineName = options.viewEngine;
-		if (!viewEngineName) {
-			const ext = path.extname(filename);
-			viewEngineName = this.viewManager.extMap.get(ext);
-		}
-		if (!viewEngineName) viewEngineName = this.config.defaultViewEngine;
-		assert(viewEngineName, `Can't find viewEngine for ${filename}`);
-		return await this[GET_VIEW_ENGINE](viewEngineName).render(filename, this[SET_LOCALS](locals), options);
-	}
-	async [RENDER_STRING](tpl, locals, options) {
-		let viewEngineName = options && options.viewEngine;
-		if (!viewEngineName) viewEngineName = this.config.defaultViewEngine;
-		assert(viewEngineName, "Can't find viewEngine");
-		return await this[GET_VIEW_ENGINE](viewEngineName).renderString(tpl, this[SET_LOCALS](locals), options);
-	}
-	[GET_VIEW_ENGINE](name) {
-		const ViewEngine = this.viewManager.get(name);
-		assert(ViewEngine, `Can't find ViewEngine "${name}"`);
-		return new ViewEngine(this.ctx);
-	}
-	/**
-	* set locals for view, inject `locals.ctx`, `locals.request`, `locals.helper`
-	* @private
-	*/
-	[SET_LOCALS](locals) {
-		return Object.assign({
-			ctx: this.ctx,
-			request: this.ctx.request,
-			helper: this.ctx.helper
-		}, this.ctx.locals, locals);
-	}
-};
-
-//#endregion
 export { ContextView };

package/dist/lib/index.d.ts

@@ -1,3 +1,5 @@
-import { PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig } from "./view_manager.js";
-import { ContextView } from "./context_view.js";
+import "../config.default-BgQBnsOY.js";
+import { PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig } from "../view_manager-c9xtBmJn.js";
+import { ContextView } from "../context_view-FFsbwt3g.js";
+import "../index-CI4LJief.js";
 export { ContextView, PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig };

package/dist/lib/index.js

@@ -1,4 +1,5 @@
-import { ViewManager } from "./view_manager.js";
-import { ContextView } from "./context_view.js";
+import { ViewManager } from "../view_manager-D6jOE8_P.js";
+import { ContextView } from "../context_view-CalYICWU.js";
+import "../lib-CKgd1dPu.js";
 
 export { ContextView, ViewManager };

package/dist/lib/view_manager.d.ts

@@ -1,61 +1,3 @@
-import { ViewConfig } from "../config/config.default.js";
-import { Application, Context } from "egg";
-
-//#region src/lib/view_manager.d.ts
-interface ViewManagerConfig extends Omit<ViewConfig, 'root'> {
-  root: string[];
-}
-type PlainObject<T = any> = {
-  [key: string]: T;
-};
-interface RenderOptions extends PlainObject {
-  name?: string;
-  root?: string;
-  locals?: PlainObject;
-  viewEngine?: string;
-}
-interface ViewEngine {
-  render: (name: string, locals?: Record<string, any>, options?: RenderOptions) => Promise<string>;
-  renderString: (tpl: string, locals?: Record<string, any>, options?: RenderOptions) => Promise<string>;
-}
-type ViewEngineClass = new (app: Context) => ViewEngine;
-/**
- * ViewManager will manage all view engine that is registered.
- *
- * It can find the real file, then retrieve the view engine based on extension.
- * The plugin just register view engine using {@link ViewManager#use}
- */
-declare class ViewManager extends Map<string, ViewEngineClass> {
-  config: ViewManagerConfig;
-  extMap: Map<string, string>;
-  fileMap: Map<string, string>;
-  /**
-   * @param {Application} app - application instance
-   */
-  constructor(app: Application);
-  /**
-   * This method can register view engine.
-   *
-   * You can define a view engine class contains two method, `render` and `renderString`
-   *
-   * ```js
-   * class View {
-   *   render() {}
-   *   renderString() {}
-   * }
-   * ```
-   * @param {String} name - the name of view engine
-   * @param {Object} viewEngine - the class of view engine
-   */
-  use(name: string, viewEngine: ViewEngineClass): void;
-  /**
-   * Resolve the path based on the given name,
-   * if the name is `user.html` and root is `app/view` (by default),
-   * it will return `app/view/user.html`
-   * @param {String} name - the given path name, it's relative to config.root
-   * @return {String} filename - the full path
-   */
-  resolve(name: string): Promise<string>;
-}
-//#endregion
+import "../config.default-BgQBnsOY.js";
+import { PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig } from "../view_manager-c9xtBmJn.js";
 export { PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig };

package/dist/lib/view_manager.js

@@ -1,83 +1,3 @@
-import path from "node:path";
-import assert from "node:assert";
-import { existsSync } from "node:fs";
-import { exists } from "utility";
-import { isGeneratorFunction } from "is-type-of";
+import { ViewManager } from "../view_manager-D6jOE8_P.js";
 
-//#region src/lib/view_manager.ts
-/**
-* ViewManager will manage all view engine that is registered.
-*
-* It can find the real file, then retrieve the view engine based on extension.
-* The plugin just register view engine using {@link ViewManager#use}
-*/
-var ViewManager = class extends Map {
-	config;
-	extMap;
-	fileMap;
-	/**
-	* @param {Application} app - application instance
-	*/
-	constructor(app) {
-		super();
-		this.config = app.config.view;
-		this.config.root = app.config.view.root.split(/\s*,\s*/g).filter((filepath) => existsSync(filepath));
-		this.extMap = /* @__PURE__ */ new Map();
-		this.fileMap = /* @__PURE__ */ new Map();
-		for (const ext of Object.keys(this.config.mapping)) this.extMap.set(ext, this.config.mapping[ext]);
-	}
-	/**
-	* This method can register view engine.
-	*
-	* You can define a view engine class contains two method, `render` and `renderString`
-	*
-	* ```js
-	* class View {
-	*   render() {}
-	*   renderString() {}
-	* }
-	* ```
-	* @param {String} name - the name of view engine
-	* @param {Object} viewEngine - the class of view engine
-	*/
-	use(name, viewEngine) {
-		assert(name, "name is required");
-		assert(!this.has(name), `${name} has been registered`);
-		assert(viewEngine, "viewEngine is required");
-		assert(viewEngine.prototype.render, "viewEngine should implement `render` method");
-		assert(!isGeneratorFunction(viewEngine.prototype.render), "viewEngine `render` method should not be generator function");
-		assert(viewEngine.prototype.renderString, "viewEngine should implement `renderString` method");
-		assert(!isGeneratorFunction(viewEngine.prototype.renderString), "viewEngine `renderString` method should not be generator function");
-		this.set(name, viewEngine);
-	}
-	/**
-	* Resolve the path based on the given name,
-	* if the name is `user.html` and root is `app/view` (by default),
-	* it will return `app/view/user.html`
-	* @param {String} name - the given path name, it's relative to config.root
-	* @return {String} filename - the full path
-	*/
-	async resolve(name) {
-		const config = this.config;
-		let filename = this.fileMap.get(name);
-		if (config.cache && filename) return filename;
-		filename = await resolvePath([name, name + config.defaultExtension], config.root);
-		assert(filename, `Can't find ${name} from ${config.root.join(",")}`);
-		this.fileMap.set(name, filename);
-		return filename;
-	}
-};
-async function resolvePath(names, root) {
-	for (const name of names) for (const dir of root) {
-		const filename = path.join(dir, name);
-		if (await exists(filename)) {
-			if (inpath(dir, filename)) return filename;
-		}
-	}
-}
-function inpath(parent, sub) {
-	return sub.indexOf(parent) > -1;
-}
-
-//#endregion
 export { ViewManager };

package/dist/lib-CKgd1dPu.js

@@ -0,0 +1 @@
+export {  };

package/dist/types-4klwWQ8h.d.ts

@@ -0,0 +1,28 @@
+import { ViewConfig } from "./config.default-BgQBnsOY.js";
+import { RenderOptions, ViewManager } from "./view_manager-c9xtBmJn.js";
+import { ContextView } from "./context_view-FFsbwt3g.js";
+
+//#region src/types.d.ts
+declare module 'egg' {
+  interface EggAppConfig {
+    /**
+     * view default config
+     * @member Config#view
+     * @property {String} [root=${baseDir}/app/view] - give a path to find the file, you can specify multiple path with `,` delimiter
+     * @property {Boolean} [cache=true] - whether cache the file's path
+     * @property {String} [defaultExtension] - defaultExtension can be added automatically when there is no extension  when call `ctx.render`
+     * @property {String} [defaultViewEngine] - set the default view engine if you don't want specify the viewEngine every request.
+     * @property {Object} mapping - map the file extension to view engine, such as `{ '.ejs': 'ejs' }`
+     */
+    view: ViewConfig;
+  }
+  interface Application {
+    get view(): ViewManager;
+  }
+  interface Context {
+    view: ContextView;
+    render(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<void>;
+    renderView(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
+    renderString(tpl: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
+  }
+}

package/dist/types-BsuPrIpu.js

@@ -0,0 +1 @@
+export {  };

package/dist/types.d.ts

@@ -1,28 +1,4 @@
-import { ViewConfig } from "./config/config.default.js";
-import { RenderOptions, ViewManager } from "./lib/view_manager.js";
-import { ContextView } from "./lib/context_view.js";
-
-//#region src/types.d.ts
-declare module 'egg' {
-  interface EggAppConfig {
-    /**
-     * view default config
-     * @member Config#view
-     * @property {String} [root=${baseDir}/app/view] - give a path to find the file, you can specify multiple path with `,` delimiter
-     * @property {Boolean} [cache=true] - whether cache the file's path
-     * @property {String} [defaultExtension] - defaultExtension can be added automatically when there is no extension  when call `ctx.render`
-     * @property {String} [defaultViewEngine] - set the default view engine if you don't want specify the viewEngine every request.
-     * @property {Object} mapping - map the file extension to view engine, such as `{ '.ejs': 'ejs' }`
-     */
-    view: ViewConfig;
-  }
-  interface Application {
-    get view(): ViewManager;
-  }
-  interface Context {
-    view: ContextView;
-    render(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<void>;
-    renderView(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
-    renderString(tpl: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string>;
-  }
-}
+import "./config.default-BgQBnsOY.js";
+import "./view_manager-c9xtBmJn.js";
+import "./context_view-FFsbwt3g.js";
+import "./types-4klwWQ8h.js";

package/dist/types.js

@@ -1 +1,3 @@
+import "./types-BsuPrIpu.js";
+
 export {  };

package/dist/view_manager-D6jOE8_P.js

@@ -0,0 +1,83 @@
+import path from "node:path";
+import assert from "node:assert";
+import { existsSync } from "node:fs";
+import { exists } from "utility";
+import { isGeneratorFunction } from "is-type-of";
+
+//#region src/lib/view_manager.ts
+/**
+* ViewManager will manage all view engine that is registered.
+*
+* It can find the real file, then retrieve the view engine based on extension.
+* The plugin just register view engine using {@link ViewManager#use}
+*/
+var ViewManager = class extends Map {
+	config;
+	extMap;
+	fileMap;
+	/**
+	* @param {Application} app - application instance
+	*/
+	constructor(app) {
+		super();
+		this.config = app.config.view;
+		this.config.root = app.config.view.root.split(/\s*,\s*/g).filter((filepath) => existsSync(filepath));
+		this.extMap = /* @__PURE__ */ new Map();
+		this.fileMap = /* @__PURE__ */ new Map();
+		for (const ext of Object.keys(this.config.mapping)) this.extMap.set(ext, this.config.mapping[ext]);
+	}
+	/**
+	* This method can register view engine.
+	*
+	* You can define a view engine class contains two method, `render` and `renderString`
+	*
+	* ```js
+	* class View {
+	*   render() {}
+	*   renderString() {}
+	* }
+	* ```
+	* @param {String} name - the name of view engine
+	* @param {Object} viewEngine - the class of view engine
+	*/
+	use(name, viewEngine) {
+		assert(name, "name is required");
+		assert(!this.has(name), `${name} has been registered`);
+		assert(viewEngine, "viewEngine is required");
+		assert(viewEngine.prototype.render, "viewEngine should implement `render` method");
+		assert(!isGeneratorFunction(viewEngine.prototype.render), "viewEngine `render` method should not be generator function");
+		assert(viewEngine.prototype.renderString, "viewEngine should implement `renderString` method");
+		assert(!isGeneratorFunction(viewEngine.prototype.renderString), "viewEngine `renderString` method should not be generator function");
+		this.set(name, viewEngine);
+	}
+	/**
+	* Resolve the path based on the given name,
+	* if the name is `user.html` and root is `app/view` (by default),
+	* it will return `app/view/user.html`
+	* @param {String} name - the given path name, it's relative to config.root
+	* @return {String} filename - the full path
+	*/
+	async resolve(name) {
+		const config = this.config;
+		let filename = this.fileMap.get(name);
+		if (config.cache && filename) return filename;
+		filename = await resolvePath([name, name + config.defaultExtension], config.root);
+		assert(filename, `Can't find ${name} from ${config.root.join(",")}`);
+		this.fileMap.set(name, filename);
+		return filename;
+	}
+};
+async function resolvePath(names, root) {
+	for (const name of names) for (const dir of root) {
+		const filename = path.join(dir, name);
+		if (await exists(filename)) {
+			if (inpath(dir, filename)) return filename;
+		}
+	}
+}
+function inpath(parent, sub) {
+	return sub.indexOf(parent) > -1;
+}
+
+//#endregion
+export { ViewManager };

package/dist/view_manager-c9xtBmJn.d.ts

@@ -0,0 +1,61 @@
+import { ViewConfig } from "./config.default-BgQBnsOY.js";
+import { Application, Context } from "egg";
+
+//#region src/lib/view_manager.d.ts
+interface ViewManagerConfig extends Omit<ViewConfig, 'root'> {
+  root: string[];
+}
+type PlainObject<T = any> = {
+  [key: string]: T;
+};
+interface RenderOptions extends PlainObject {
+  name?: string;
+  root?: string;
+  locals?: PlainObject;
+  viewEngine?: string;
+}
+interface ViewEngine {
+  render: (name: string, locals?: Record<string, any>, options?: RenderOptions) => Promise<string>;
+  renderString: (tpl: string, locals?: Record<string, any>, options?: RenderOptions) => Promise<string>;
+}
+type ViewEngineClass = new (app: Context) => ViewEngine;
+/**
+ * ViewManager will manage all view engine that is registered.
+ *
+ * It can find the real file, then retrieve the view engine based on extension.
+ * The plugin just register view engine using {@link ViewManager#use}
+ */
+declare class ViewManager extends Map<string, ViewEngineClass> {
+  config: ViewManagerConfig;
+  extMap: Map<string, string>;
+  fileMap: Map<string, string>;
+  /**
+   * @param {Application} app - application instance
+   */
+  constructor(app: Application);
+  /**
+   * This method can register view engine.
+   *
+   * You can define a view engine class contains two method, `render` and `renderString`
+   *
+   * ```js
+   * class View {
+   *   render() {}
+   *   renderString() {}
+   * }
+   * ```
+   * @param {String} name - the name of view engine
+   * @param {Object} viewEngine - the class of view engine
+   */
+  use(name: string, viewEngine: ViewEngineClass): void;
+  /**
+   * Resolve the path based on the given name,
+   * if the name is `user.html` and root is `app/view` (by default),
+   * it will return `app/view/user.html`
+   * @param {String} name - the given path name, it's relative to config.root
+   * @return {String} filename - the full path
+   */
+  resolve(name: string): Promise<string>;
+}
+//#endregion
+export { PlainObject, RenderOptions, ViewEngine, ViewEngineClass, ViewManager, ViewManagerConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/view",
-  "version": "4.0.0-beta.18",
+  "version": "4.0.0-beta.20",
   "description": "Base view plugin for egg",
   "publishConfig": {
     "access": "public"
@@ -51,14 +51,14 @@
     "utility": "^2.5.0"
   },
   "peerDependencies": {
-    "egg": "4.1.0-beta.18"
+    "egg": "4.1.0-beta.20"
   },
   "devDependencies": {
     "tsdown": "^0.15.4",
-    "typescript": "5.9.2",
-    "vitest": "4.0.0-beta.13",
-    "@eggjs/mock": "7.0.0-beta.18",
-    "@eggjs/tsconfig": "3.1.0-beta.18"
+    "typescript": "^5.9.3",
+    "vitest": "4.0.0-beta.16",
+    "@eggjs/mock": "7.0.0-beta.20",
+    "@eggjs/tsconfig": "3.1.0-beta.20"
   },
   "scripts": {
     "lint": "oxlint --type-aware",