@eggjs/view 3.0.1 → 4.0.0-beta.17

package/src/app/extend/application.ts

@@ -1,25 +0,0 @@
-import { EggCore } from '@eggjs/core';
-import { ViewManager } from '../../lib/view_manager.js';
-
-const VIEW = Symbol('Application#view');
-
-export default class Application extends EggCore {
-  [VIEW]: ViewManager;
-
-  /**
-   * Retrieve ViewManager instance
-   * @member {ViewManager} Application#view
-   */
-  get view(): ViewManager {
-    if (!this[VIEW]) {
-      this[VIEW] = new ViewManager(this);
-    }
-    return this[VIEW];
-  }
-}
-
-declare module '@eggjs/core' {
-  interface EggCore {
-    get view(): ViewManager;
-  }
-}

package/src/app/extend/context.ts

@@ -1,66 +0,0 @@
-import { Context } from '@eggjs/core';
-import { ContextView } from '../../lib/context_view.js';
-import { RenderOptions } from '../../lib/view_manager.js';
-
-const VIEW = Symbol('Context#view');
-
-export default 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
-   */
-  async render(name: string, locals?: Record<string, any>, options?: RenderOptions): Promise<void> {
-    const body = await this.renderView(name, locals, options);
-    this.body = body;
-  }
-
-  /**
-   * 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: string,
-    locals?: Record<string, any>,
-    options?: RenderOptions,
-  ): Promise<string> {
-    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: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string> {
-    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];
-  }
-}
-
-declare module '@eggjs/core' {
-  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/src/config/config.default.ts

@@ -1,56 +0,0 @@
-import path from 'node:path';
-import type { EggAppInfo } from '@eggjs/core';
-
-/**
- * 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' }`
- */
-export 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>;
-}
-
-export default (appInfo: EggAppInfo) => ({
-  view: {
-    root: path.join(appInfo.baseDir, 'app/view'),
-    cache: true,
-    defaultExtension: '.html',
-    defaultViewEngine: '',
-    mapping: {},
-  },
-});
-
-declare module '@eggjs/core' {
-  // add EggAppConfig overrides types
-  interface EggAppConfig {
-    view: ViewConfig;
-  }
-}

package/src/config/config.local.ts

@@ -1,7 +0,0 @@
-import type { EggAppConfig } from '@eggjs/core';
-
-export default {
-  view: {
-    cache: false,
-  },
-} as EggAppConfig;

package/src/index.ts

@@ -1,3 +0,0 @@
-import './config/config.default.js';
-import './app/extend/application.js';
-import './app/extend/context.js';

package/src/lib/context_view.ts

@@ -1,111 +0,0 @@
-import path from 'node:path';
-import assert from 'node:assert';
-import type { Context, EggCore } from '@eggjs/core';
-import { ViewManager, type ViewManagerConfig, type RenderOptions } from './view_manager.js';
-
-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}.
- */
-export class ContextView {
-  protected ctx: Context;
-  protected app: EggCore;
-  protected viewManager: ViewManager;
-  protected config: ViewManagerConfig;
-
-  constructor(ctx: Context) {
-    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: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string> {
-    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: string, locals?: Record<string, any>, options?: RenderOptions): Promise<string> {
-    return await this[RENDER_STRING](tpl, locals, options);
-  }
-
-  // ext -> viewEngineName -> viewEngine
-  async [RENDER](name: string, locals?: Record<string, any>, options: RenderOptions = {}) {
-    // retrieve fullpath matching name from `config.root`
-    const filename = await this.viewManager.resolve(name);
-    options.name = name;
-    options.root = filename.replace(path.normalize(name), '').replace(/[\/\\]$/, '');
-    options.locals = locals;
-
-    // get the name of view engine,
-    // if viewEngine is specified in options, don't match extension
-    let viewEngineName = options.viewEngine;
-    if (!viewEngineName) {
-      const ext = path.extname(filename);
-      viewEngineName = this.viewManager.extMap.get(ext);
-    }
-    // use the default view engine that is configured if no matching above
-    if (!viewEngineName) {
-      viewEngineName = this.config.defaultViewEngine;
-    }
-    assert(viewEngineName, `Can't find viewEngine for ${filename}`);
-
-    // get view engine and render
-    const viewEngine = this[GET_VIEW_ENGINE](viewEngineName);
-    return await viewEngine.render(filename, this[SET_LOCALS](locals), options);
-  }
-
-  async [RENDER_STRING](tpl: string, locals?: Record<string, any>, options?: RenderOptions) {
-    let viewEngineName = options && options.viewEngine;
-    if (!viewEngineName) {
-      viewEngineName = this.config.defaultViewEngine;
-    }
-    assert(viewEngineName, 'Can\'t find viewEngine');
-
-    // get view engine and render
-    const viewEngine = this[GET_VIEW_ENGINE](viewEngineName);
-    return await viewEngine.renderString(tpl, this[SET_LOCALS](locals), options);
-  }
-
-  [GET_VIEW_ENGINE](name: string) {
-    // get view engine
-    const ViewEngine = this.viewManager.get(name);
-    assert(ViewEngine, `Can't find ViewEngine "${name}"`);
-
-    // use view engine to render
-    const engine = new ViewEngine(this.ctx);
-    return engine;
-  }
-
-  /**
-   * set locals for view, inject `locals.ctx`, `locals.request`, `locals.helper`
-   * @private
-   */
-  [SET_LOCALS](locals?: Record<string, any>) {
-    return Object.assign({
-      ctx: this.ctx,
-      request: this.ctx.request,
-      helper: this.ctx.helper,
-    }, this.ctx.locals, locals);
-  }
-}

package/src/lib/view_manager.ts

@@ -1,122 +0,0 @@
-import assert from 'node:assert';
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { exists } from 'utility';
-import type { Context, EggCore } from '@eggjs/core';
-import { isGeneratorFunction } from 'is-type-of';
-import type { ViewConfig } from '../config/config.default.js';
-
-export interface ViewManagerConfig extends Omit<ViewConfig, 'root'> {
-  root: string[];
-}
-
-export type PlainObject<T = any> = { [key: string]: T };
-
-export interface RenderOptions extends PlainObject {
-  name?: string;
-  root?: string;
-  locals?: PlainObject;
-  viewEngine?: string;
-}
-
-export interface ViewEngine {
-  render: (name: string, locals?: Record<string, any>, options?: RenderOptions) => Promise<string>;
-  renderString: (tpl: string, locals?: Record<string, any>, options?: RenderOptions) => Promise<string>;
-}
-
-export 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}
- */
-export class ViewManager extends Map<string, ViewEngineClass> {
-  config: ViewManagerConfig;
-  extMap: Map<string, string>;
-  fileMap: Map<string, string>;
-
-  /**
-   * @param {Application} app - application instance
-   */
-  constructor(app: EggCore) {
-    super();
-    this.config = app.config.view as any;
-    this.config.root = app.config.view.root
-      .split(/\s*,\s*/g)
-      .filter(filepath => existsSync(filepath));
-    this.extMap = new Map();
-    this.fileMap = 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: string, viewEngine: ViewEngineClass) {
-    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: string): Promise<string> {
-    const config = this.config;
-
-    // check cache
-    let filename = this.fileMap.get(name);
-    if (config.cache && filename) return filename;
-
-    // try find it with default extension
-    filename = await resolvePath([ name, name + config.defaultExtension ], config.root);
-    assert(filename, `Can't find ${name} from ${config.root.join(',')}`);
-
-    // set cache
-    this.fileMap.set(name, filename);
-    return filename;
-  }
-}
-
-async function resolvePath(names: string[], root: string[]) {
-  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: string, sub: string) {
-  return sub.indexOf(parent) > -1;
-}

package/src/typings/index.d.ts

@@ -1,4 +0,0 @@
-// make sure to import egg typings and let typescript know about it
-// @see https://github.com/whxaxes/blog/issues/11
-// and https://www.typescriptlang.org/docs/handbook/declaration-merging.html
-import 'egg';