feat: support AST minification (#1474)

Author: kazupon

packages/core-base/src/format.ts

@@ -10,6 +10,7 @@ import type {
   LinkedNode,
   LinkedKeyNode,
   LinkedModifierNode,
+  PluralNode,
   ResourceNode
 } from '@intlify/message-compiler'
 import type {
@@ -24,18 +25,19 @@ export function format<Message = string>(
 ): MessageFunction<Message> {
   const msg = (ctx: MessageContext<Message>): MessageFunctionReturn<Message> =>
     formatParts<Message>(ctx, ast)
-  // TODO: add meta data for vue-devtools debugging, such as `key`, `source` and `locale`
-  // TODO: optimization for static text message
   return msg
 }
 
 function formatParts<Message = string>(
   ctx: MessageContext<Message>,
   ast: ResourceNode
 ): MessageFunctionReturn<Message> {
-  if (ast.body.type === NodeTypes.Plural) {
+  const body = ast.b || ast.body
+  if ((body.t || body.type) === NodeTypes.Plural) {
+    const plural = body as PluralNode
+    const cases = plural.c || plural.cases
     return ctx.plural(
-      ast.body.cases.reduce(
+      cases.reduce(
         (messages, c) =>
           [
             ...messages,
@@ -45,20 +47,21 @@ function formatParts<Message = string>(
       ) as Message[]
     ) as MessageFunctionReturn<Message>
   } else {
-    return formatMessageParts(ctx, ast.body)
+    return formatMessageParts(ctx, body as MessageNode)
   }
 }
 
 function formatMessageParts<Message = string>(
   ctx: MessageContext<Message>,
   node: MessageNode
 ): MessageFunctionReturn<Message> {
-  if (node.static) {
+  const _static = node.s || node.static
+  if (_static) {
     return ctx.type === 'text'
-      ? (node.static as MessageFunctionReturn<Message>)
-      : ctx.normalize([node.static] as MessageType<Message>[])
+      ? (_static as MessageFunctionReturn<Message>)
+      : ctx.normalize([_static] as MessageType<Message>[])
   } else {
-    const messages = node.items.reduce(
+    const messages = (node.i || node.items).reduce(
       (acm, c) => [...acm, formatMessagePart(ctx, c)],
       [] as MessageType<Message>[]
     )
@@ -70,30 +73,35 @@ function formatMessagePart<Message = string>(
   ctx: MessageContext<Message>,
   node: Node
 ): MessageType<Message> {
-  switch (node.type) {
+  const type = node.t || node.type
+  switch (type) {
     case NodeTypes.Text:
-      return (node as TextNode).value as MessageType<Message>
+      const text = node as TextNode
+      return (text.v || text.value) as MessageType<Message>
     case NodeTypes.Literal:
-      return (node as LiteralNode).value as MessageType<Message>
+      const literal = node as LiteralNode
+      return (literal.v || literal.value) as MessageType<Message>
     case NodeTypes.Named:
-      return ctx.interpolate(ctx.named((node as NamedNode).key))
+      const named = node as NamedNode
+      return ctx.interpolate(ctx.named(named.k || named.key))
     case NodeTypes.List:
-      return ctx.interpolate(ctx.list((node as ListNode).index))
+      const list = node as ListNode
+      return ctx.interpolate(ctx.list(list.i || list.index))
     case NodeTypes.Linked:
+      const linked = node as LinkedNode
+      const modifier = linked.m || linked.modifier
       return ctx.linked(
-        formatMessagePart(ctx, (node as LinkedNode).key) as string,
-        (node as LinkedNode).modifier
-          ? (formatMessagePart(ctx, (node as LinkedNode).modifier!) as string)
-          : undefined,
+        formatMessagePart(ctx, linked.k || linked.key) as string,
+        modifier ? (formatMessagePart(ctx, modifier) as string) : undefined,
         ctx.type
       )
     case NodeTypes.LinkedKey:
-      return (node as LinkedKeyNode).value as MessageType<Message>
+      const linkedKey = node as LinkedKeyNode
+      return (linkedKey.v || linkedKey.value) as MessageType<Message>
     case NodeTypes.LinkedModifier:
-      return (node as LinkedModifierNode).value as MessageType<Message>
+      const linkedModifier = node as LinkedModifierNode
+      return (linkedModifier.v || linkedModifier.value) as MessageType<Message>
     default:
-      throw new Error(
-        `unhandled node type on format message part: ${node.type}`
-      )
+      throw new Error(`unhandled node type on format message part: ${type}`)
   }
 }

packages/core-base/test/compilation.test.ts

@@ -37,13 +37,31 @@ describe('compile', () => {
     expect(msg(ctx)).toBe('hello kazupon!')
   })
 
-  test('AST passing', () => {
-    const { ast } = baseCompile('hello {name}!')
-    const msg = compile(ast)
-    const ctx = context({
-      named: { name: 'kazupon' }
+  describe('AST', () => {
+    test('basic', () => {
+      const { ast } = baseCompile('hello {name}!', {
+        location: false,
+        jit: true
+      })
+      const msg = compile(ast)
+      const ctx = context({
+        named: { name: 'kazupon' }
+      })
+      expect(msg(ctx)).toBe('hello kazupon!')
+    })
+
+    test('minify', () => {
+      const { ast } = baseCompile('hello {name}!', {
+        location: false,
+        jit: true,
+        minify: true
+      })
+      const msg = compile(ast)
+      const ctx = context({
+        named: { name: 'kazupon' }
+      })
+      expect(msg(ctx)).toBe('hello kazupon!')
     })
-    expect(msg(ctx)).toBe('hello kazupon!')
   })
 
   test('error', () => {

packages/message-compiler/src/compiler.ts

@@ -1,6 +1,7 @@
 import { createParser } from './parser'
 import { transform } from './transformer'
 import { optimize } from './optimizer'
+import { minify } from './minifier'
 import { generate } from './generator'
 import { assign } from '@intlify/shared'
 
@@ -15,7 +16,8 @@ export function baseCompile(
 ): CompilerResult {
   const assignedOptions = assign({}, options)
   const jit = !!assignedOptions.jit
-  const doOptimize =
+  const enalbeMinify = !!assignedOptions.minify
+  const enambeOptimize =
     assignedOptions.optimize == null ? true : assignedOptions.optimize
 
   // parse source codes
@@ -30,7 +32,10 @@ export function baseCompile(
     return generate(ast, assignedOptions)
   } else {
     // optimize ASTs
-    doOptimize && optimize(ast)
+    enambeOptimize && optimize(ast)
+
+    // minimize ASTs
+    enalbeMinify && minify(ast)
 
     // In JIT mode, no ast transform, no code generation.
     return { ast, code: '' }

packages/message-compiler/src/minifier.ts

@@ -0,0 +1,95 @@
+import { NodeTypes } from './nodes'
+
+import type {
+  MessageNode,
+  ResourceNode,
+  Node,
+  PluralNode,
+  TextNode,
+  LiteralNode,
+  LinkedNode,
+  LinkedKeyNode,
+  LinkedModifierNode,
+  ListNode,
+  NamedNode
+} from './nodes'
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export function minify(node: Node) {
+  node.t = node.type
+
+  switch (node.type) {
+    case NodeTypes.Resource:
+      const resource = node as ResourceNode
+      minify(resource.body)
+      resource.b = resource.body
+      delete (resource as any).body
+      break
+    case NodeTypes.Plural:
+      const plural = node as PluralNode
+      const cases = plural.cases
+      for (let i = 0; i < cases.length; i++) {
+        minify(cases[i])
+      }
+      plural.c = cases
+      delete (plural as any).cases
+      break
+    case NodeTypes.Message:
+      const message = node as MessageNode
+      const items = message.items
+      for (let i = 0; i < items.length; i++) {
+        minify(items[i])
+      }
+      message.i = items
+      delete (message as any).items
+      if (message.static) {
+        message.s = message.static
+        delete (message as any).static
+      }
+      break
+    case NodeTypes.Text:
+    case NodeTypes.Literal:
+    case NodeTypes.LinkedModifier:
+    case NodeTypes.LinkedKey:
+      const valueNode = node as
+        | TextNode
+        | LiteralNode
+        | LinkedKeyNode
+        | LinkedModifierNode
+      if (valueNode.value) {
+        valueNode.v = valueNode.value
+        delete (valueNode as any).value
+      }
+      break
+    case NodeTypes.Linked:
+      const linked = node as LinkedNode
+      minify(linked.key)
+      linked.k = linked.key
+      delete (linked as any).key
+      if (linked.modifier) {
+        minify(linked.modifier)
+        linked.m = linked.modifier
+        delete (linked as any).modifier
+      }
+      break
+    case NodeTypes.List:
+      const list = node as ListNode
+      list.i = list.index
+      delete (list as any).index
+      break
+    case NodeTypes.Named:
+      const named = node as NamedNode
+      named.k = named.key
+      delete (named as any).key
+      break
+    default:
+      if (__DEV__) {
+        throw new Error(`unhandled minify node type: ${node.type}`)
+      }
+  }
+
+  delete (node as any).type
+}
+
+/* eslint-enable @typescript-eslint/no-explicit-any */

packages/message-compiler/src/nodes.ts

@@ -18,6 +18,10 @@ export type Identifier = string
 
 export interface Node {
   type: NodeTypes
+  /**
+   * @internal `type` alias
+   */
+  t?: NodeTypes
   start?: number
   end?: number
   loc?: SourceLocation
@@ -26,19 +30,35 @@ export interface Node {
 export interface ResourceNode extends Node {
   type: NodeTypes.Resource
   body: MessageNode | PluralNode
+  /**
+   * @internal `body` alias
+   */
+  b?: MessageNode | PluralNode
   cacheKey?: string
   helpers?: string[]
 }
 
 export interface PluralNode extends Node {
   type: NodeTypes.Plural
   cases: MessageNode[]
+  /**
+   * @internal `cases` alias
+   */
+  c?: MessageNode[]
 }
 
 export interface MessageNode extends Node {
   type: NodeTypes.Message
   static?: string
+  /**
+   * @internal `static` alias
+   */
+  s?: string
   items: MessageElementNode[]
+  /**
+   * @internal `items` alias
+   */
+  i?: MessageElementNode[]
 }
 
 type MessageElementNode =
@@ -51,35 +71,67 @@ type MessageElementNode =
 export interface TextNode extends Node {
   type: NodeTypes.Text
   value?: string
+  /**
+   * @internal `value` alias
+   */
+  v?: string
 }
 
 export interface NamedNode extends Node {
   type: NodeTypes.Named
   key: Identifier
+  /**
+   * @internal `key` alias
+   */
+  k?: Identifier
 }
 
 export interface ListNode extends Node {
   type: NodeTypes.List
   index: number
+  /**
+   * @internal `index` alias
+   */
+  i?: number
 }
 
 export interface LiteralNode extends Node {
   type: NodeTypes.Literal
   value?: string
+  /**
+   * @internal `value` alias
+   */
+  v?: string
 }
 
 export interface LinkedNode extends Node {
   type: NodeTypes.Linked
   modifier?: LinkedModifierNode
+  /**
+   * @internal `modifier` alias
+   */
+  m?: LinkedModifierNode
   key: LinkedKeyNode | NamedNode | ListNode | LiteralNode
+  /**
+   * @internal `key` alias
+   */
+  k?: LinkedKeyNode | NamedNode | ListNode | LiteralNode
 }
 
 export interface LinkedKeyNode extends Node {
   type: NodeTypes.LinkedKey
   value: string
+  /**
+   * @internal `value` alias
+   */
+  v?: string
 }
 
 export interface LinkedModifierNode extends Node {
   type: NodeTypes.LinkedModifier
   value: Identifier
+  /**
+   * @internal `value` alias
+   */
+  v?: Identifier
 }

packages/message-compiler/src/options.ts

@@ -34,6 +34,7 @@ export interface CodeGenOptions {
 
 export type CompileOptions = {
   optimize?: boolean // default true
+  minify?: boolean // default false
   jit?: boolean // default false
 } & TransformOptions &
   CodeGenOptions &