@travetto/doc 7.0.0-rc.1 → 7.0.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/doc",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.2",
   "description": "Documentation support for the Travetto framework",
   "keywords": [
     "docs",
@@ -24,12 +24,12 @@
     "directory": "module/doc"
   },
   "dependencies": {
-    "@travetto/runtime": "^7.0.0-rc.1",
+    "@travetto/runtime": "^7.0.0-rc.2",
     "@types/prismjs": "^1.26.5",
     "prismjs": "^1.30.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.0-rc.1"
+    "@travetto/cli": "^7.0.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/jsx.ts

@@ -64,7 +64,7 @@ export type JSXElements = { [K in keyof C]: JSXElementByFn<K>; };
 
 export const EMPTY_ELEMENT = EMPTY;
 
-const invertedC = new Map<Function, string>(TypedObject.entries(c).map<[Function, string]>(p => [p[1], p[0]]));
+const invertedC = new Map<Function, string>(TypedObject.entries(c).map<[Function, string]>(([name, cls]) => [cls, name]));
 
 export function getComponentName(fn: Function | string): string {
   if (typeof fn === 'string') {

package/src/render/code-highlight.ts

@@ -34,18 +34,18 @@ export function highlight(text: string, lang: string): string | undefined {
   });
 
   text = text
-    .replace(/&#(\d+);/g, (x, code) => String.fromCharCode(code))
+    .replace(/&#(\d+);/g, (_, code) => String.fromCharCode(code))
     .replace(/&[a-z][^;]*;/g, a => tokenMapping[a] || a);
 
   try {
     return prismJs.highlight(text, prismJs.languages[lang], lang)
       .replace(/(@\s*<span[^>]*)function("\s*>)/g, (a, pre, post) => `${pre}meta${post}`)
       .replace(/[{}]/g, a => `{{'${a}'}}`);
-  } catch (err) {
-    if (err instanceof Error) {
-      console.error(err.message, { error: err });
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message, { error });
     } else {
-      throw err;
+      throw error;
     }
   }
 }

package/src/render/html.ts

@@ -13,23 +13,23 @@ import { RenderContext } from './context.ts';
 import { DocResolveUtil } from '../util/resolve.ts';
 
 const ESCAPE_ENTITIES: Record<string, string> = { '<': '&lt;', '>': '&gt;', '&': '&amp;', '{': "{{'{'}}", '}': "{{'}'}}" };
-const ENTITY_RE = new RegExp(`[${Object.keys(ESCAPE_ENTITIES).join('')}]`, 'gm');
+const ENTITY_REGEX = new RegExp(`[${Object.keys(ESCAPE_ENTITIES).join('')}]`, 'gm');
 
-const stdInline = async ({ recurse, el }: RenderState<JSXElement, RenderContext>): Promise<string> =>
-  `<${el.type}>${await recurse()}</${el.type}>`;
+const stdInline = async ({ recurse, node }: RenderState<JSXElement, RenderContext>): Promise<string> =>
+  `<${node.type}>${await recurse()}</${node.type}>`;
 
-const std = async ({ recurse, el }: RenderState<JSXElement, RenderContext>): Promise<string> =>
-  `<${el.type}>${await recurse()}</${el.type}>\n`;
+const std = async ({ recurse, node }: RenderState<JSXElement, RenderContext>): Promise<string> =>
+  `<${node.type}>${await recurse()}</${node.type}>\n`;
 
-const stdFull = async ({ recurse, el }: RenderState<JSXElement, RenderContext>): Promise<string> =>
-  `\n<${el.type}>${await recurse()}</${el.type}>\n`;
+const stdFull = async ({ recurse, node }: RenderState<JSXElement, RenderContext>): Promise<string> =>
+  `\n<${node.type}>${await recurse()}</${node.type}>\n`;
 
 export const Html: RenderProvider<RenderContext> = {
   ext: 'html',
   finalize: (text, context) => {
     const brand = `<!-- ${context.generatedStamp} -->\n<!-- ${context.rebuildStamp} -->`;
     const cleaned = text
-      .replace(/(<[/](?:a)>)([A-Za-z0-9$])/g, (_, tag, v) => `${tag} ${v}`)
+      .replace(/(<[/](?:a)>)([A-Za-z0-9$])/g, (_, tag, value) => `${tag} ${value}`)
       .replace(/(<[uo]l>)(<li>)/g, (_, a, b) => `${a} ${b}`);
     return `${brand}\n${cleaned}`;
   },
@@ -39,10 +39,10 @@ export const Html: RenderProvider<RenderContext> = {
   h2: stdFull, h3: stdFull, h4: stdFull,
   li: std, ol: stdFull, ul: stdFull,
   table: stdFull, thead: std, tr: std, td: std, tbody: std,
-  Execution: async ({ context, el, props, createState }) => {
-    const output = await context.execute(el);
+  Execution: async ({ context, node, props, createState }) => {
+    const output = await context.execute(node);
     const displayCmd = props.config?.formatCommand?.(props.cmd, props.args ?? []) ??
-      `${el.props.cmd} ${(el.props.args ?? []).join(' ')}`;
+      `${node.props.cmd} ${(node.props.args ?? []).join(' ')}`;
     const sub = createState('Terminal', {
       language: 'bash',
       title: props.title,
@@ -50,18 +50,18 @@ export const Html: RenderProvider<RenderContext> = {
     });
     return Html.Terminal(sub);
   },
-  Install: async ({ context, el }) => {
+  Install: async ({ context, node }) => {
     const highlighted = highlight(`
-npm install ${el.props.pkg}
+npm install ${node.props.pkg}
 
 # or
 
-yarn add ${el.props.pkg}
+yarn add ${node.props.pkg}
 `, 'bash');
 
     return `\n
   <figure class="install">
-    <figcaption class="install">Install ${el.props.title}
+    <figcaption class="install">Install ${node.props.title}
     
     </figcaption>
     <pre><code class="language-bash">${highlighted}</code></pre>
@@ -70,11 +70,11 @@ yarn add ${el.props.pkg}
   },
   Terminal: state => Html.Code(state),
   Config: state => Html.Code(state),
-  Code: async ({ context, el, props }) => {
-    DocResolveUtil.applyCodePropDefaults(el.props);
+  Code: async ({ context, node, props }) => {
+    DocResolveUtil.applyCodePropDefaults(node.props);
 
-    const cls = getComponentName(el.type).replace(/^[A-Z]/g, v => v.toLowerCase());
-    const content = await context.resolveCode(el);
+    const cls = getComponentName(node.type).replace(/^[A-Z]/g, value => value.toLowerCase());
+    const content = await context.resolveCode(node);
     let link: string = '';
     if ('src' in props && content.file) {
       let linkCtx: { file: string, line?: number } = { file: content.file! };
@@ -85,9 +85,9 @@ yarn add ${el.props.pkg}
     }
     let lang = props.language ?? content.language;
     if (!lang) {
-      if (el.type === c.Terminal) {
+      if (node.type === c.Terminal) {
         lang = 'bash';
-      } else if (el.type === c.Code) {
+      } else if (node.type === c.Code) {
         lang = 'typescript';
       }
     }
@@ -112,12 +112,12 @@ yarn add ${el.props.pkg}
   Path: state => Html.Input(state),
   Class: state => Html.Input(state),
   Field: state => Html.Input(state),
-  Input: async ({ el, context }) => {
-    const cls = getComponentName(el.type).replace(/^[A-Z]/g, v => v.toLowerCase());
-    return `<code class="item ${cls}">${context.cleanText(el.props.name.replace(ENTITY_RE, k => ESCAPE_ENTITIES[k]))}</code>`;
+  Input: async ({ node, context }) => {
+    const cls = getComponentName(node.type).replace(/^[A-Z]/g, value => value.toLowerCase());
+    return `<code class="item ${cls}">${context.cleanText(node.props.name.replace(ENTITY_REGEX, key => ESCAPE_ENTITIES[key]))}</code>`;
   },
-  CodeLink: async ({ context, props, el }) => {
-    const target = await context.resolveCodeLink(el);
+  CodeLink: async ({ context, props, node }) => {
+    const target = await context.resolveCodeLink(node);
     return `<a target="_blank" class="source-link" href="${context.link(target.file, target)}">${props.title}</a>`;
   },
   Anchor: async ({ context, props }) =>
@@ -134,24 +134,24 @@ yarn add ${el.props.pkg}
   },
 
   Mod: async ({ context, props }) => {
-    const cfg = MOD_MAPPING[props.name];
-    return `<a class="module-link" href="${context.link(cfg.folder, cfg)}" title="${cfg.description}">${cfg.displayName}</a>`;
+    const config = MOD_MAPPING[props.name];
+    return `<a class="module-link" href="${context.link(config.folder, config)}" title="${config.description}">${config.displayName}</a>`;
   },
   Library: async ({ context, props }) => {
-    const cfg = LIB_MAPPING[props.name];
-    return `<a target="_blank" class="external-link" href="${context.link(cfg.href, cfg)}">${cfg.title}</a>`;
+    const config = LIB_MAPPING[props.name];
+    return `<a target="_blank" class="external-link" href="${context.link(config.href, config)}">${config.title}</a>`;
   },
 
   Note: async ({ recurse }) => `\n\n<p class="note"><strong>Note</strong> ${await recurse()}</p>\n`,
   Header: async ({ props }) => `<h1>${props.title} ${props.description ? `\n<small>${props.description}</small>\n` : ''}</h1>\n`,
 
   StdHeader: async state => {
-    const mod = state.el.props.mod ?? Runtime.main.name;
+    const mod = state.node.props.mod ?? Runtime.main.name;
     const pkg = PackageUtil.readPackage(RuntimeIndex.getModule(mod)!.sourcePath);
     const title = pkg.travetto?.displayName ?? pkg.name;
     const desc = pkg.description;
     let install = '';
-    if (state.el.props.install !== false) {
+    if (state.node.props.install !== false) {
       const sub = state.createState('Install', {
         title: pkg.name,
         pkg: pkg.name,

package/src/render/markdown.ts

@@ -15,8 +15,8 @@ export const Markdown: RenderProvider<RenderContext> = {
   finalize: (text, context) => {
     const brand = `<!-- ${context.generatedStamp} -->\n<!-- ${context.rebuildStamp} -->`;
     const cleaned = text
-      .replace(/(\[[^\]]+\]\([^)]+\))([A-Za-z0-9$]+)/g, (_, link, v) => v === 's' ? _ : `${link} ${v}`)
-      .replace(/(\S)\n(#)/g, (_, l, r) => `${l}\n\n${r}`);
+      .replace(/(\[[^\]]+\]\([^)]+\))([A-Za-z0-9$]+)/g, (_, link, value) => value === 's' ? _ : `${link} ${value}`)
+      .replace(/(\S)\n(#)/g, (_, left, right) => `${left}\n\n${right}`);
     return `${brand}\n${cleaned}`;
   },
   strong: async ({ recurse }) => `**${await recurse()}**`,
@@ -26,8 +26,8 @@ export const Markdown: RenderProvider<RenderContext> = {
   ul: async ({ recurse }) => `\n${await recurse()}\n`,
   ol: async ({ recurse }) => `\n${await recurse()}\n`,
   li: async ({ recurse, stack }) => {
-    const parent = stack.toReversed().find(x => x.type === 'ol' || x.type === 'ul');
-    const depth = stack.filter(x => x.type === 'ol' || x.type === 'ul').length;
+    const parent = stack.toReversed().find(node => node.type === 'ol' || node.type === 'ul');
+    const depth = stack.filter(node => node.type === 'ol' || node.type === 'ul').length;
     return `${'   '.repeat(depth)}${(parent && parent.type === 'ol') ? '1.' : '* '} ${await recurse()}\n`;
   },
   table: async ({ recurse }) => `${await recurse()}`,
@@ -41,37 +41,37 @@ export const Markdown: RenderProvider<RenderContext> = {
   h2: async ({ recurse }) => `\n## ${await recurse()}\n\n`,
   h3: async ({ recurse }) => `\n### ${await recurse()}\n\n`,
   h4: async ({ recurse }) => `\n#### ${await recurse()}\n\n`,
-  Execution: async ({ context, el, props, createState }) => {
-    const output = await context.execute(el);
+  Execution: async ({ context, node, props, createState }) => {
+    const output = await context.execute(node);
     const displayCmd = props.config?.formatCommand?.(props.cmd, props.args ?? []) ??
-      `${el.props.cmd} ${(el.props.args ?? []).join(' ')}`;
+      `${node.props.cmd} ${(node.props.args ?? []).join(' ')}`;
     const state = createState('Terminal', {
       language: 'bash',
-      title: el.props.title,
+      title: node.props.title,
       src: [`$ ${displayCmd}`, '', context.cleanText(output)].join('\n')
     });
     return Markdown.Terminal(state);
   },
-  Install: async ({ context, el }) =>
-    `\n\n**Install: ${el.props.title}**
+  Install: async ({ context, node }) =>
+    `\n\n**Install: ${node.props.title}**
 \`\`\`bash
-npm install ${el.props.pkg}
+npm install ${node.props.pkg}
 
 # or
 
-yarn add ${el.props.pkg}
+yarn add ${node.props.pkg}
 \`\`\`
 `,
-  Code: async ({ context, el, props }) => {
-    DocResolveUtil.applyCodePropDefaults(el.props);
+  Code: async ({ context, node, props }) => {
+    DocResolveUtil.applyCodePropDefaults(node.props);
 
-    const name = getComponentName(el.type);
-    const content = await context.resolveCode(el);
+    const name = getComponentName(node.type);
+    const content = await context.resolveCode(node);
     let lang = props.language ?? content.language;
     if (!lang) {
-      if (el.type === c.Terminal) {
+      if (node.type === c.Terminal) {
         lang = 'bash';
-      } else if (el.type === c.Code) {
+      } else if (node.type === c.Code) {
         lang = 'typescript';
       }
     }
@@ -83,9 +83,9 @@ ${context.cleanText(content.text)}
   Terminal: state => Markdown.Code(state),
   Config: state => Markdown.Code(state),
 
-  Section: async ({ el, recurse }) => `\n## ${el.props.title}\n${await recurse()}\n`,
-  SubSection: async ({ el, recurse }) => `\n### ${el.props.title}\n${await recurse()}\n`,
-  SubSubSection: async ({ el, recurse }) => `\n#### ${el.props.title}\n${await recurse()}\n`,
+  Section: async ({ node, recurse }) => `\n## ${node.props.title}\n${await recurse()}\n`,
+  SubSection: async ({ node, recurse }) => `\n### ${node.props.title}\n${await recurse()}\n`,
+  SubSubSection: async ({ node, recurse }) => `\n#### ${node.props.title}\n${await recurse()}\n`,
 
   Command: state => Markdown.Input(state),
   Method: state => Markdown.Input(state),
@@ -98,8 +98,8 @@ ${context.cleanText(content.text)}
   File: state => Markdown.Ref(state),
   Ref: async ({ context, props }) => `[${props.title}](${context.link(props.href, props)})`,
 
-  CodeLink: async ({ context, props, el }) => {
-    const target = await context.resolveCodeLink(el);
+  CodeLink: async ({ context, props, node }) => {
+    const target = await context.resolveCodeLink(node);
     return `[${props.title}](${context.link(target.file, target)})`;
   },
 
@@ -113,23 +113,23 @@ ${context.cleanText(content.text)}
   Header: async ({ props }) => `# ${props.title}\n${props.description ? `## ${props.description}\n` : ''}\n`,
 
   StdHeader: async state => {
-    const mod = state.el.props.mod ?? Runtime.main.name;
+    const mod = state.node.props.mod ?? Runtime.main.name;
     const pkg = PackageUtil.readPackage(RuntimeIndex.getModule(mod)!.sourcePath);
     const title = pkg.travetto?.displayName ?? pkg.name;
     const desc = pkg.description;
     let install = '';
-    if (state.el.props.install !== false) {
+    if (state.node.props.install !== false) {
       const sub = state.createState('Install', { title: pkg.name, pkg: pkg.name });
       install = await Markdown.Install(sub);
     }
     return `# ${title}\n${desc ? `## ${desc}\n` : ''}${install}\n`;
   },
   Mod: async ({ props, context }) => {
-    const cfg = MOD_MAPPING[props.name];
-    return `[${cfg.displayName}](${context.link(cfg.folder, cfg)}#readme "${cfg.description}")`;
+    const config = MOD_MAPPING[props.name];
+    return `[${config.displayName}](${context.link(config.folder, config)}#readme "${config.description}")`;
   },
   Library: async ({ props }) => {
-    const cfg = LIB_MAPPING[props.name];
-    return `[${cfg.title}](${cfg.href})`;
+    const config = LIB_MAPPING[props.name];
+    return `[${config.title}](${config.href})`;
   }
 };

package/src/render/prism.d.ts

@@ -2,7 +2,7 @@ declare namespace PrismAlt {
   export interface Grammar { }
   export const languages: { [language: string]: Grammar; };
   export const plugins: Record<string, {
-    setDefaults(cfg: Record<string, unknown>): void;
+    setDefaults(config: Record<string, unknown>): void;
     normalize(text: string, config?: unknown): string;
   }>;
   export function highlight(

package/src/render/renderer.ts

@@ -20,10 +20,10 @@ const providers = { [Html.ext]: Html, [Markdown.ext]: Markdown };
 export class DocRenderer {
 
   static async get(file: string, manifest: Pick<ManifestContext, 'workspace'>): Promise<DocRenderer> {
-    const res = await Runtime.importFrom<DocumentShape>(file);
+    const document = await Runtime.importFrom<DocumentShape>(file);
     const pkg = PackageUtil.readPackage(manifest.workspace.path);
     const repoBaseUrl = pkg.travetto?.doc?.baseUrl ?? manifest.workspace.path;
-    return new DocRenderer(res,
+    return new DocRenderer(document,
       new RenderContext(file, repoBaseUrl, path.resolve(pkg.travetto?.doc?.root ?? manifest.workspace.path))
     );
   }
@@ -45,14 +45,14 @@ export class DocRenderer {
     const source = DocFileUtil.readSource(cls);
     if (source) {
       title = (await DocFileUtil.isDecorator(cls.name, source.file)) ? `@${title ?? cls.name}` : (title ?? cls.name);
-      const el = this.#support.createElement('CodeLink', {
+      const node = this.#support.createElement('CodeLink', {
         src: source.file,
         startRe: new RegExp(`(class|function|interface)\\s+(${cls.name.replaceAll('$', '\\$')})`),
         title
       });
       // @ts-expect-error
       const state: RenderState<JSXElementByFn<'CodeLink'>, RenderContext> = {
-        el, props: el.props, recurse: async () => '', context: this.#support, stack: []
+        node, props: node.props, recurse: async () => '', context: this.#support, stack: []
       };
       // @ts-expect-error
       state.createState = (key, props) => this.createState(state, key, props);
@@ -62,26 +62,26 @@ export class DocRenderer {
 
   async #render(
     renderer: RenderProvider<RenderContext>,
-    node: JSXElement[] | JSXElement | string | bigint | object | number | boolean | null | undefined,
+    input: JSXElement[] | JSXElement | string | bigint | object | number | boolean | null | undefined,
     stack: JSXElement[] = []
   ): Promise<string | undefined> {
 
-    if (node === null || node === undefined) {
+    if (input === null || input === undefined) {
       return '';
-    } else if (Array.isArray(node)) {
+    } else if (Array.isArray(input)) {
       const out: string[] = [];
-      for (const el of node) {
-        const sub = await this.#render(renderer, el, stack);
+      for (const node of input) {
+        const sub = await this.#render(renderer, node, stack);
         if (sub) {
           out.push(sub);
         }
       }
       return out.join('');
-    } else if (isJSXElement(node)) {
-      let final: JSXElement = node;
+    } else if (isJSXElement(input)) {
+      let final: JSXElement = input;
       // Render simple element if needed
-      if (typeof node.type === 'function' && node.type !== JSXFragmentType) {
-        const out = castTo<Function>(node.type)(node.props);
+      if (typeof input.type === 'function' && input.type !== JSXFragmentType) {
+        const out = castTo<Function>(input.type)(input.props);
         final = out !== EMPTY_ELEMENT ? out : final;
       }
 
@@ -98,7 +98,7 @@ export class DocRenderer {
         const recurse = () => this.#render(renderer, final.props.children ?? [], [...stack, final]);
         // @ts-expect-error
         const state: RenderState<JSXElement, RenderContext> = {
-          el: final, props: final.props, recurse, stack, context: this.#support
+          node: final, props: final.props, recurse, stack, context: this.#support
         };
         state.createState = (key, props) => this.createState(state, key, props);
         // @ts-expect-error
@@ -108,22 +108,22 @@ export class DocRenderer {
         throw new Error(`Unknown element: ${final.type}`);
       }
     } else {
-      switch (typeof node) {
-        case 'string': return node.replace(/&nbsp;/g, ' ');
+      switch (typeof input) {
+        case 'string': return input.replace(/&nbsp;/g, ' ');
         case 'number':
         case 'bigint':
-        case 'boolean': return `${node}`;
+        case 'boolean': return `${input}`;
         case 'object': {
-          if (node) {
-            return await this.#buildLink(renderer, castTo(node.constructor), node.constructor.name.replace(/^[$]/, ''));
+          if (input) {
+            return await this.#buildLink(renderer, castTo(input.constructor), input.constructor.name.replace(/^[$]/, ''));
           }
           break;
         }
         case 'function': {
-          return await this.#buildLink(renderer, castTo(node));
+          return await this.#buildLink(renderer, castTo(input));
         }
       }
-      throw new Error(`Unknown object type: ${typeof node}`);
+      throw new Error(`Unknown object type: ${typeof input}`);
     }
   }
 
@@ -133,28 +133,28 @@ export class DocRenderer {
     props: JSXElementByFn<K>['props']
     // @ts-expect-error
   ): RenderState<JSXElementByFn<K>, RenderContext> {
-    const el = this.#support.createElement(key, props);
-    return { ...state, el, props: el.props };
+    const node = this.#support.createElement(key, props);
+    return { ...state, node, props: node.props };
   }
 
   /**
    * Render a context given a specific renderer
    * @param renderer
    */
-  async render(fmt: keyof typeof providers): Promise<string> {
-    if (!providers[fmt]) {
-      throw new Error(`Unknown renderer with format: ${fmt}`);
+  async render(format: keyof typeof providers): Promise<string> {
+    if (!providers[format]) {
+      throw new Error(`Unknown renderer with format: ${format}`);
     }
     if (!this.#rootNode) {
       this.#rootNode = (Array.isArray(this.#root.text) || isJSXElement(this.#root.text)) ?
         this.#root.text : await (this.#root.text());
     }
 
-    const text = await this.#render(providers[fmt], this.#rootNode);
+    const text = await this.#render(providers[format], this.#rootNode);
     let cleaned = `${text?.replace(/\n{3,100}/msg, '\n\n').trim()}\n`;
-    if (this.#root.wrap?.[fmt]) {
-      cleaned = this.#root.wrap[fmt](cleaned);
+    if (this.#root.wrap?.[format]) {
+      cleaned = this.#root.wrap[format](cleaned);
     }
-    return providers[fmt].finalize(cleaned, this.#support);
+    return providers[format].finalize(cleaned, this.#support);
   }
 }

package/src/types.ts

@@ -13,7 +13,7 @@ export interface DocumentShape {
 }
 
 export type RenderState<T extends JSXElement, C> = {
-  el: T;
+  node: T;
   props: T['props'];
   recurse: () => Promise<string | undefined>;
   stack: JSXElement[];

package/src/util/file.ts

@@ -31,40 +31,40 @@ export class DocFileUtil {
 
   static #decCache: Record<string, boolean> = {};
 
-  static isFile(src: string): boolean {
-    return /^[@:A-Za-z0-9\/\\\-_.]+[.]([a-z]{2,10})$/.test(src);
+  static isFile(file: string): boolean {
+    return /^[@:A-Za-z0-9\/\\\-_.]+[.]([a-z]{2,10})$/.test(file);
   }
 
-  static readSource(src: string | Function): { content: string, language: string, file: string } {
+  static readSource(input: string | Function): { content: string, language: string, file: string } {
     let file: string | undefined;
     let content: string | undefined;
 
-    if (typeof src === 'string') {
-      if (src.includes('\n') || src.includes(' ')) {
-        content = src;
+    if (typeof input === 'string') {
+      if (input.includes('\n') || input.includes(' ')) {
+        content = input;
       } else {
-        const resolved = path.resolve(src);
+        const resolved = path.resolve(input);
         if (existsSync(resolved)) {
           content = readFileSync(resolved, 'utf8');
           file = resolved;
         } else {
-          file = RuntimeIndex.getSourceFile(src);
+          file = RuntimeIndex.getSourceFile(input);
           content = readFileSync(file, 'utf8');
         }
       }
     } else {
-      file = Runtime.getSourceFile(src);
+      file = Runtime.getSourceFile(input);
       if (!existsSync(file)) {
-        throw new AppError(`Unknown file: ${typeof src === 'string' ? src : src.name} => ${file}`);
+        throw new AppError(`Unknown file: ${typeof input === 'string' ? input : input.name} => ${file}`);
       }
       content = readFileSync(file, 'utf8');
     }
 
     if (content) {
       content = content.split(/\n/)
-        .map(x => x
+        .map(line => line
           .replace(ESLINT_PATTERN, '')
-          .replace(ENV_KEY, (_, k) => `'${k}'`)
+          .replace(ENV_KEY, (_, key) => `'${key}'`)
         )
         .join('\n')
         .replace(/^\/\/# sourceMap.*$/gsm, '')
@@ -83,12 +83,12 @@ export class DocFileUtil {
     }
   }
 
-  static async readCodeSnippet(src: string | Function, startPattern: RegExp): Promise<{ file: string, startIdx: number, lines: string[], language: string }> {
-    const result = this.readSource(src);
+  static async readCodeSnippet(input: string | Function, startPattern: RegExp): Promise<{ file: string, startIdx: number, lines: string[], language: string }> {
+    const result = this.readSource(input);
     const lines = result.content.split(/\n/);
-    const startIdx = lines.findIndex(l => startPattern.test(l));
+    const startIdx = lines.findIndex(line => startPattern.test(line));
     if (startIdx < 0) {
-      throw new Error(`Pattern ${startPattern.source} not found in ${src}`);
+      throw new Error(`Pattern ${startPattern.source} not found in ${input}`);
     }
     return { file: result.file, startIdx, lines, language: result.language };
   }
@@ -106,7 +106,7 @@ export class DocFileUtil {
     const text = await this.readSource(file);
     const lines = text.content.split(/\n/g);
 
-    const start = lines.findIndex(x => new RegExp(`function ${name}\\b`).test(x));
+    const start = lines.findIndex(line => new RegExp(`function ${name}\\b`).test(line));
     let found = false;
     if (start > 0) {
       for (let i = start - 1; i > start - 3; i--) {
@@ -126,30 +126,30 @@ export class DocFileUtil {
    */
   static buildOutline(code: string): string {
     let methodPrefix = '';
-    code = code.split(/\n/).map((x) => {
+    code = code.split(/\n/).map((line) => {
       if (!methodPrefix) {
-        const info = x.match(/^(\s{0,50})(?:(private|public)\s{1,10})?(?:static\s{1,10})?(?:async\s{1,10})?(?:[*]\s{0,10})?(?:(?:get|set)\s{1,10})?(\S{1,200})[<(](.{0,500})/);
+        const info = line.match(/^(\s{0,50})(?:(private|public)\s{1,10})?(?:static\s{1,10})?(?:async\s{1,10})?(?:[*]\s{0,10})?(?:(?:get|set)\s{1,10})?(\S{1,200})[<(](.{0,500})/);
         if (info) {
           const [, space, __name, rest] = info;
           if (!rest.endsWith(';')) {
-            if (/\s{0,50}[{]\s{0,50}return.{0,200}$/.test(x)) {
-              return x.replace(/\s{0,50}[{]\s{0,50}return.{0,200}$/, ';');
+            if (/\s{0,50}[{]\s{0,50}return.{0,200}$/.test(line)) {
+              return line.replace(/\s{0,50}[{]\s{0,50}return.{0,200}$/, ';');
             } else {
               methodPrefix = space;
-              return x.replace(/\s{0,50}[{]\s{0,50}$/, ';');
+              return line.replace(/\s{0,50}[{]\s{0,50}$/, ';');
             }
           }
         }
-        return x;
+        return line;
       } else {
-        if (x.startsWith(`${methodPrefix}}`)) {
+        if (line.startsWith(`${methodPrefix}}`)) {
           methodPrefix = '';
         }
         return '';
       }
     })
-      .filter(x => !/#|(\b(private|protected)\b)/.test(x))
-      .filter(x => !!x)
+      .filter(line => !/#|(\b(private|protected)\b)/.test(line))
+      .filter(line => !!line)
       .join('\n');
 
     return code;

package/src/util/resolve.ts

@@ -19,7 +19,7 @@ export class DocResolveUtil {
 
     if (result.content) {
       line = result.content.split(/\n/g)
-        .findIndex(x => new RegExp(`(class|interface|function)[ ]+${title.replaceAll('$', '\\$')}`).test(x));
+        .findIndex(lineText => new RegExp(`(class|interface|function)[ ]+${title.replaceAll('$', '\\$')}`).test(lineText));
       if (line < 0) {
         line = 0;
       } else {
@@ -50,7 +50,7 @@ export class DocResolveUtil {
   static async resolveSnippet(file: Function | string, startPattern: RegExp, endPattern?: RegExp, outline = false): Promise<ResolvedSnippet> {
     const { lines, startIdx, language, file: resolvedFile } = await DocFileUtil.readCodeSnippet(file, startPattern);
 
-    const endIdx = endPattern ? lines.findIndex((l, i) => i > startIdx && endPattern.test(l)) : lines.length;
+    const endIdx = endPattern ? lines.findIndex((line, i) => i > startIdx && endPattern.test(line)) : lines.length;
     let text = lines.slice(startIdx, endIdx + 1).join('\n');
 
     if (outline) {

package/src/util/run.ts

@@ -25,7 +25,10 @@ class DocState {
 
   getId(id: string): string {
     if (!this.ids[id]) {
-      this.ids[id] = ' '.repeat(id.length).split('').map(x => Math.trunc(this.rng() * 16).toString(16)).join('');
+      this.ids[id] = ' '.repeat(id.length)
+        .split('')
+        .map(_ => Math.trunc(this.rng() * 16).toString(16))
+        .join('');
     }
     return this.ids[id];
   }
@@ -37,18 +40,18 @@ class DocState {
 export class DocRunUtil {
   static #docState = new DocState();
 
-  /** Build cwd from config */
-  static cwd(cfg: RunConfig): string {
-    return path.resolve(cfg.module ? RuntimeIndex.getModule(cfg.module)?.sourcePath! : Runtime.mainSourcePath);
+  /** Build working directory from config */
+  static workingDirectory(config: RunConfig): string {
+    return path.resolve(config.module ? RuntimeIndex.getModule(config.module)?.sourcePath! : Runtime.mainSourcePath);
   }
 
   /**
    * Clean run output
    */
-  static cleanRunOutput(text: string, cfg: RunConfig): string {
-    const cwd = this.cwd(cfg);
+  static cleanRunOutput(text: string, config: RunConfig): string {
+    const rootPath = this.workingDirectory(config);
     text = util.stripVTControlCharacters(text.trim())
-      .replaceAll(cwd, '.')
+      .replaceAll(rootPath, '.')
       .replaceAll(os.tmpdir(), '/tmp')
       .replaceAll(Runtime.workspace.path, '<workspace-root>')
       .replace(/[/]tmp[/][a-z_A-Z0-9\/\-]+/g, '/tmp/<temp-folder>')
@@ -58,12 +61,12 @@ export class DocRunUtil {
       .replace(/[A-Za-z0-9_.\-\/\\]+\/travetto\/module\//g, '@travetto/')
       .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}([.]\d{3})?Z?/g, this.#docState.getDate.bind(this.#docState))
       .replace(/\b[0-9a-f]{4}[0-9a-f\-]{8,40}\b/ig, this.#docState.getId.bind(this.#docState))
-      .replace(/(\d+[.]\d+[.]\d+)-(alpha|rc)[.]\d+/g, (all, v) => v);
-    if (cfg.filter) {
-      text = text.split(/\n/g).filter(cfg.filter).join('\n');
+      .replace(/(\d+[.]\d+[.]\d+)-(alpha|rc)[.]\d+/g, (all, value) => value);
+    if (config.filter) {
+      text = text.split(/\n/g).filter(config.filter).join('\n');
     }
-    if (cfg.rewrite) {
-      text = cfg.rewrite(text);
+    if (config.rewrite) {
+      text = config.rewrite(text);
     }
     return text;
   }
@@ -73,7 +76,7 @@ export class DocRunUtil {
    */
   static spawn(cmd: string, args: string[], config: RunConfig = {}): ChildProcess {
     return spawn(cmd, args, {
-      cwd: config.cwd ?? this.cwd(config),
+      cwd: config.workingDirectory ?? this.workingDirectory(config),
       env: {
         ...process.env,
         ...Env.DEBUG.export(false),
@@ -95,17 +98,17 @@ export class DocRunUtil {
   static async run(cmd: string, args: string[], config: RunConfig = {}): Promise<string> {
     let final: string;
     try {
-      const proc = this.spawn(cmd, args, config);
-      const result = await ExecUtil.getResult(proc, { catch: true });
+      const subProcess = this.spawn(cmd, args, config);
+      const result = await ExecUtil.getResult(subProcess, { catch: true });
       if (!result.valid) {
         throw new Error(result.stderr);
       }
       final = util.stripVTControlCharacters(result.stdout).trim() || util.stripVTControlCharacters(result.stderr).trim();
-    } catch (err) {
-      if (err instanceof Error) {
-        final = err.message;
+    } catch (error) {
+      if (error instanceof Error) {
+        final = error.message;
       } else {
-        throw err;
+        throw error;
       }
     }
 

package/src/util/types.ts

@@ -4,7 +4,7 @@ export type RunConfig = {
   module?: string;
   env?: Record<string, string>;
   envName?: string;
-  cwd?: string;
+  workingDirectory?: string;
 };
 
 export type CodeProps = { title?: string, src: string | Function, language?: string, outline?: boolean, startRe?: RegExp, endRe?: RegExp };

package/support/cli.doc.ts

@@ -52,15 +52,15 @@ export class DocCommand implements CliCommandShape {
       return;
     }
 
-    const args = process.argv.slice(2).filter(x => !/(-w|--watch)/.test(x));
+    const args = process.argv.slice(2).filter(arg => !/(-w|--watch)/.test(arg));
     for await (const { action, file } of watchCompiler({ restartOnExit: true })) {
       if (action === 'update' && file === this.input) {
-        const proc = spawn('npx', ['trv', ...args], {
+        const subProcess = spawn('npx', ['trv', ...args], {
           cwd: Runtime.mainSourcePath,
           env: { ...process.env, ...Env.TRV_QUIET.export(true) },
           stdio: 'inherit'
         });
-        await ExecUtil.getResult(proc, { catch: true });
+        await ExecUtil.getResult(subProcess, { catch: true });
       }
     }
   }
@@ -73,8 +73,8 @@ export class DocCommand implements CliCommandShape {
         [output, null] as const
     );
 
-    for (const [fmt, out] of outputs) {
-      const result = await ctx.render(fmt);
+    for (const [format, out] of outputs) {
+      const result = await ctx.render(format);
       if (out) {
         const finalName = path.resolve(out);
         await fs.writeFile(finalName, result, 'utf8');