wuchale 0.23.4 → 0.24.0

package/dist/adapter-utils/mixed-visitor.d.ts

@@ -1,10 +1,18 @@
-import type MagicString from 'magic-string';
-import { type HeuristicDetails, type HeuristicDetailsBase, type HeuristicFunc, type IndexTracker, type Message, type MessageType } from '../adapters.js';
+import MagicString from 'magic-string';
+import { type HeuristicDetails, type HeuristicDetailsBase, type HeuristicFunc, IndexTracker, type Message } from '../adapters.js';
 import { type CommentDirectives, type RuntimeVars } from './index.js';
 type NestedRanges = [number, number, boolean][];
-type InitProps<MixNodeT, TxtT extends MixNodeT, ComT extends MixNodeT, ExprT extends MixNodeT> = {
-    vars: () => RuntimeVars;
+type VisitVolatileCtx<A> = {
     mstr: MagicString;
+    index: IndexTracker;
+    inCompoundText: boolean;
+    addCtx: A;
+};
+type VisitNestedCtx<A> = Omit<VisitVolatileCtx<A>, 'inCompoundText'>;
+type VisitFunc<MixNodeT, AddCtx> = (node: MixNodeT, ctx: VisitVolatileCtx<AddCtx>) => Message[];
+type InitProps<MixNodeT, AddCtx extends object, TxtT extends MixNodeT, ComT extends MixNodeT, ExprT extends MixNodeT> = {
+    vars: () => RuntimeVars;
+    content: string;
     getRange: (node: MixNodeT) => {
         start: number;
         end: number;
@@ -16,18 +24,15 @@ type InitProps<MixNodeT, TxtT extends MixNodeT, ComT extends MixNodeT, ExprT ext
     canHaveChildren: (node: MixNodeT) => boolean;
     getTextContent: (node: TxtT) => string;
     getCommentData: (node: ComT) => string;
-    visitFunc: (node: MixNodeT, inCompoundText: boolean) => Message[];
-    visitExpressionTag: (node: ExprT) => Message[];
+    visitFunc: VisitFunc<MixNodeT, AddCtx>;
     fullHeuristicDetails: (details: HeuristicDetailsBase) => HeuristicDetails;
     checkHeuristic: HeuristicFunc;
     wrapNested: (msgInfo: Message, hasExprs: boolean, nestedRanges: NestedRanges, lastChildEnd: number) => void;
-    index: IndexTracker;
 };
 export type MixedScope = 'markup' | 'attribute';
-type VisitProps<NodeT> = {
+type VisitProps<NodeT, AddCtx> = VisitVolatileCtx<AddCtx> & {
     children: NodeT[];
     commentDirectives: CommentDirectives;
-    inCompoundText: boolean;
     scope: MixedScope;
     element: string;
     attribute?: string;
@@ -36,11 +41,13 @@ type VisitProps<NodeT> = {
      * e.g. components in jsx to prevent `[object Object]` being rendered. */
     useComponent?: boolean;
 };
-type SeparateVisitRes = [boolean, boolean, boolean, MessageType, Message[]];
-export declare class MixedVisitor<MixNodeT, TxtT extends MixNodeT, ComT extends MixNodeT, ExprT extends MixNodeT> {
+export declare class MixedVisitor<MixNodeT, AddCtx extends object, TxtT extends MixNodeT, ComT extends MixNodeT, ExprT extends MixNodeT> {
     #private;
-    constructor(props: InitProps<MixNodeT, TxtT, ComT, ExprT>);
-    separatelyVisitChildren: (props: VisitProps<MixNodeT>) => SeparateVisitRes;
-    visit: (props: VisitProps<MixNodeT>) => Message[];
+    constructor(props: InitProps<MixNodeT, AddCtx, TxtT, ComT, ExprT>);
+    separatelyVisitChildren: (props: VisitProps<MixNodeT, AddCtx>) => Message[];
+    visitNested(props: VisitProps<MixNodeT, AddCtx>, ctx: VisitNestedCtx<AddCtx>, asCompound: true): Message[];
+    visitNested(props: VisitProps<MixNodeT, AddCtx>, ctx: VisitNestedCtx<AddCtx>, asCompound: false): boolean;
+    visit: (props: VisitProps<MixNodeT, AddCtx>) => Message[];
+    static withCtxRestore<MixNodeT, AddCtx>(transformer: VisitVolatileCtx<AddCtx>, visitChild: (child: MixNodeT) => Message[]): VisitFunc<MixNodeT, AddCtx>;
 }
 export {};

package/dist/adapter-utils/mixed-visitor.js

@@ -1,56 +1,25 @@
 // Shared logic between adapters for handling nested / mixed elements within elements / fragments
-import { getKey, newMessage, } from '../adapters.js';
+import MagicString from 'magic-string';
+import { getKey, IndexTracker, newMessage, } from '../adapters.js';
 import { commentPrefix, nonWhitespaceText, restoreCommentDirectives, updateCommentDirectives, varNames, } from './index.js';
+const noopIndex = new IndexTracker(true);
+const noopMstr = new Proxy(new MagicString(''), {
+    get: (target, p) => {
+        if (typeof target[p] === 'function') {
+            return () => { };
+        }
+        return target[p];
+    },
+});
 export class MixedVisitor {
     #props;
     constructor(props) {
         this.#props = props;
     }
     separatelyVisitChildren = (props) => {
-        let hasTextChild = false;
-        let hasNonTextChild = false;
-        let heurStr = '';
-        let hasCommentDirectives = false;
-        for (const child of props.children) {
-            if (this.#props.isText(child)) {
-                const strContent = this.#props.getTextContent(child);
-                if (!strContent.trim()) {
-                    continue;
-                }
-                hasTextChild = true;
-                heurStr += strContent;
-            }
-            else if (this.#props.isComment(child)) {
-                if (this.#props.getCommentData(child).trim().startsWith(commentPrefix)) {
-                    hasCommentDirectives = true;
-                }
-            }
-            else if (!this.#props.leaveInPlace(child)) {
-                hasNonTextChild = true;
-                heurStr += `#`;
-            }
-        }
-        heurStr = heurStr.trimEnd();
-        const msg = newMessage({
-            msgStr: [heurStr],
-            details: this.#props.fullHeuristicDetails({
-                scope: props.scope,
-                element: props.element,
-                attribute: props.attribute,
-            }),
-        });
-        const heurMsgType = this.#props.checkHeuristic(msg);
-        if (heurMsgType || props.commentDirectives.unit) {
-            const hasCompoundText = hasTextChild && hasNonTextChild;
-            if (props.inCompoundText || props.commentDirectives.unit || (hasCompoundText && !hasCommentDirectives)) {
-                return [false, hasTextChild, hasCompoundText, heurMsgType || 'message', []];
-            }
-        }
-        // can't be extracted as one; visit each separately if markup
         const msgs = [];
-        const res = [true, false, false, heurMsgType || 'message', msgs];
         if (props.scope !== 'markup') {
-            return res;
+            return msgs;
         }
         const commentDirectivesOrig = { ...props.commentDirectives };
         let lastVisitIsComment = false;
@@ -67,7 +36,12 @@ export class MixedVisitor {
                 break;
             }
             if (props.commentDirectives.forceType !== false) {
-                msgs.push(...this.#props.visitFunc(child, props.inCompoundText));
+                msgs.push(...this.#props.visitFunc(child, {
+                    mstr: props.mstr,
+                    index: props.index,
+                    addCtx: props.addCtx,
+                    inCompoundText: false,
+                }));
             }
             if (!lastVisitIsComment) {
                 continue;
@@ -75,26 +49,25 @@ export class MixedVisitor {
             restoreCommentDirectives(props.commentDirectives, commentDirectivesOrig);
             lastVisitIsComment = false;
         }
-        return res;
+        return msgs;
     };
-    visit = (props) => {
-        if (props.children.length === 0) {
-            return [];
-        }
-        const [visitedSeparately, hasTextChild, hasCompoundText, heurMsgType, separateTxts] = this.separatelyVisitChildren(props);
-        if (visitedSeparately) {
-            return separateTxts;
-        }
+    visitNested(props, ctx, asCompound) {
+        let hasTextChild = false;
+        let hasNonTextChild = false;
+        let hasCommentDirectives = false;
+        let hasTextDescendants = false;
         let msgStr = '';
         let iArg = 0;
         let iTag = 0;
         const lastChildEnd = this.#props.getRange(props.children.slice(-1)[0]).end;
         const childrenNestedRanges = [];
-        let hasTextDescendants = false;
         const msgs = [];
         const placeholders = [];
         for (const child of props.children) {
             if (this.#props.isComment(child)) {
+                if (this.#props.getCommentData(child).trim().startsWith(commentPrefix)) {
+                    hasCommentDirectives = true;
+                }
                 continue;
             }
             const chRange = this.#props.getRange(child);
@@ -112,45 +85,47 @@ export class MixedVisitor {
                     // whitespace
                     continue;
                 }
+                hasTextChild = true;
                 msgStr += msgInfo.msgStr;
                 if (endWh) {
                     msgStr += ' ';
                 }
-                this.#props.mstr.remove(chRange.start, chRange.end);
+                ctx.mstr.remove(chRange.start, chRange.end);
+                continue;
+            }
+            if (this.#props.leaveInPlace(child)) {
+                msgs.push(...this.#props.visitFunc(child, { ...ctx, inCompoundText: this.#props.canHaveChildren(child) }));
                 continue;
             }
+            hasNonTextChild = true;
             if (this.#props.isExpression(child)) {
-                msgs.push(...this.#props.visitExpressionTag(child));
-                if (!hasCompoundText) {
-                    continue;
-                }
+                msgs.push(...this.#props.visitFunc(child, { ...ctx, inCompoundText: props.inCompoundText }));
                 msgStr += `{${iArg}}`;
-                placeholders.push([iArg, this.#props.mstr.original.slice(chRange.start + 1, chRange.end - 1)]);
+                placeholders.push([iArg.toString(), this.#props.content.slice(chRange.start + 1, chRange.end - 1)]);
                 let moveStart = chRange.start;
                 if (iArg > 0) {
-                    this.#props.mstr.update(chRange.start, chRange.start + 1, ', ');
+                    ctx.mstr.update(chRange.start, chRange.start + 1, ', ');
                 }
                 else {
                     moveStart++;
-                    this.#props.mstr.remove(chRange.start, chRange.start + 1);
+                    ctx.mstr.remove(chRange.start, chRange.start + 1);
                 }
-                this.#props.mstr.move(moveStart, chRange.end - 1, lastChildEnd);
-                this.#props.mstr.remove(chRange.end - 1, chRange.end);
+                ctx.mstr.move(moveStart, chRange.end - 1, lastChildEnd);
+                ctx.mstr.remove(chRange.end - 1, chRange.end);
                 iArg++;
                 continue;
             }
-            if (this.#props.leaveInPlace(child)) {
-                msgs.push(...this.#props.visitFunc(child, this.#props.canHaveChildren(child)));
-                continue;
-            }
             // elements, components and other things as well
             const canHaveChildren = this.#props.canHaveChildren(child);
-            const childMsgs = this.#props.visitFunc(child, canHaveChildren);
+            const childMsgs = this.#props.visitFunc(child, { ...ctx, inCompoundText: asCompound });
             let nestedNeedsCtx = false;
             let chTxt = '';
             for (const msgInfo of childMsgs) {
                 if (canHaveChildren && msgInfo.details.scope === props.scope) {
                     chTxt += msgInfo.msgStr[0];
+                    for (const [num, cont] of msgInfo.placeholders) {
+                        placeholders.push([`${iTag}.${num}`, cont]);
+                    }
                     hasTextDescendants = true;
                     nestedNeedsCtx = true;
                 }
@@ -170,17 +145,28 @@ export class MixedVisitor {
             iTag++;
             msgStr += chTxt;
         }
-        msgStr = msgStr.trim();
-        if (!msgStr) {
-            return msgs;
-        }
         const msgInfo = newMessage({
-            msgStr: [msgStr],
-            details: this.#props.fullHeuristicDetails({ scope: props.scope }),
+            msgStr: [msgStr.trim()],
+            details: this.#props.fullHeuristicDetails({
+                scope: props.scope,
+                element: props.element,
+                attribute: props.attribute,
+            }),
             context: props.commentDirectives.context,
+            placeholders,
         });
-        msgInfo.type = heurMsgType;
-        msgInfo.placeholders = placeholders;
+        const heurMsgType = this.#props.checkHeuristic(msgInfo);
+        msgInfo.type = heurMsgType || 'message';
+        const canBeCompound = props.inCompoundText ||
+            props.commentDirectives.unit ||
+            (hasTextChild && hasNonTextChild && !hasCommentDirectives);
+        const allChecksPassed = props.commentDirectives.unit || (canBeCompound && heurMsgType);
+        if (!asCompound) {
+            return allChecksPassed;
+        }
+        if (!allChecksPassed) {
+            return msgs;
+        }
         if (hasTextChild || hasTextDescendants) {
             msgs.push(msgInfo);
         }
@@ -189,34 +175,57 @@ export class MixedVisitor {
         }
         if (((props.useComponent ?? true) && props.scope === 'markup' && iArg > 0) || childrenNestedRanges.length > 0) {
             this.#props.wrapNested(msgInfo, iArg > 0, childrenNestedRanges, lastChildEnd);
+            return msgs;
+        }
+        // no need for component use
+        let begin = '{';
+        let end = ')}';
+        if (props.inCompoundText) {
+            begin += `${this.#props.vars().rtTransCtx}(${this.#props.vars().nestCtx}`;
         }
         else {
-            // no need for component use
-            let begin = '{';
-            let end = ')}';
-            if (props.inCompoundText) {
-                begin += `${this.#props.vars().rtTransCtx}(${this.#props.vars().nestCtx}`;
+            if (msgInfo.type === 'url') {
+                begin += `${varNames.urlLocalize}(`;
+                end = `), ${this.#props.vars().rtLocale}${end}`;
             }
-            else {
-                if (msgInfo.type === 'url') {
-                    begin += `${varNames.urlLocalize}(`;
-                    end = `), ${this.#props.vars().rtLocale}${end}`;
-                }
-                begin += `${this.#props.vars().rtTrans}(${this.#props.index.get(getKey(msgInfo.msgStr, msgInfo.context))}`;
-            }
-            if (iArg > 0) {
-                begin += ', [';
-                end = `]${end}`;
-            }
-            if (props.scope === 'attribute' && `'"`.includes(this.#props.mstr.original[lastChildEnd])) {
-                const firstChild = props.children[0];
-                const { start } = this.#props.getRange(firstChild);
-                this.#props.mstr.remove(start - 1, start);
-                this.#props.mstr.remove(lastChildEnd, lastChildEnd + 1);
-            }
-            this.#props.mstr.appendLeft(lastChildEnd, begin);
-            this.#props.mstr.appendRight(lastChildEnd, end);
+            begin += `${this.#props.vars().rtTrans}(${props.index.get(getKey(msgInfo.msgStr, msgInfo.context))}`;
+        }
+        if (iArg > 0) {
+            begin += ', [';
+            end = `]${end}`;
         }
+        if (props.scope === 'attribute' && `'"`.includes(this.#props.content[lastChildEnd])) {
+            const firstChild = props.children[0];
+            const { start } = this.#props.getRange(firstChild);
+            ctx.mstr.remove(start - 1, start);
+            ctx.mstr.remove(lastChildEnd, lastChildEnd + 1);
+        }
+        ctx.mstr.appendLeft(lastChildEnd, begin);
+        ctx.mstr.appendRight(lastChildEnd, end);
         return msgs;
+    }
+    visit = (props) => {
+        if (props.children.length === 0) {
+            return [];
+        }
+        if (!this.visitNested(props, { mstr: noopMstr, index: noopIndex, addCtx: { ...props.addCtx } }, false)) {
+            return this.separatelyVisitChildren(props);
+        }
+        return this.visitNested(props, { mstr: props.mstr, index: props.index, addCtx: props.addCtx }, true); // really modify
     };
+    static withCtxRestore(transformer, visitChild) {
+        return (child, ctx) => {
+            const prevCtx = {
+                inCompoundText: transformer.inCompoundText,
+                mstr: transformer.mstr,
+                index: transformer.index,
+                addCtx: transformer.addCtx,
+            };
+            Object.assign(transformer, ctx);
+            const msgs = visitChild(child);
+            // restore
+            Object.assign(transformer, prevCtx);
+            return msgs;
+        };
+    }
 }

package/dist/adapter-vanilla/index.js

@@ -1,6 +1,6 @@
 // $$ cd .. && npm run test
 import { loaderPathResolver } from '../adapter-utils/index.js';
-import { defaultGenerateLoadID, defaultHeuristicFuncOnly } from '../adapters.js';
+import { defaultHeuristicFuncOnly } from '../adapters.js';
 import { fillDefaults } from '../config.js';
 import { pofile } from '../pofile.js';
 import { Transformer } from './transformer.js';
@@ -15,9 +15,11 @@ export const defaultArgs = {
     storage: pofile(),
     patterns: [pluralPattern],
     heuristic: defaultHeuristicFuncOnly,
-    granularLoad: false,
-    bundleLoad: false,
-    generateLoadID: defaultGenerateLoadID,
+    loading: {
+        direct: false,
+        granular: false,
+        group: [],
+    },
     loader: 'vite',
     runtime: {
         initReactive: ({ nested }) => (nested ? null : false),
@@ -51,9 +53,9 @@ export function getDefaultLoaderPath(loader, bundle) {
 export const adapter = (args = defaultArgs) => {
     const { heuristic, patterns, runtime, loader, ...rest } = fillDefaults(args, defaultArgs);
     return {
-        transform: ({ content, filename, index, expr, matchUrl }) => new Transformer(content, filename, index, heuristic, patterns, expr, runtime, matchUrl).transform(),
+        transform: ctx => new Transformer(ctx, heuristic, patterns, runtime).transform(),
         loaderExts: ['.js', '.ts'],
-        defaultLoaderPath: getDefaultLoaderPath(loader, rest.bundleLoad),
+        defaultLoaderPath: getDefaultLoaderPath(loader, rest.loading.direct),
         runtime,
         ...rest,
     };

package/dist/adapter-vanilla/inertvisitors.d.ts

@@ -0,0 +1,31 @@
+import type { Message } from '../adapters.js';
+export default class {
+    visitEmptyStatement(): Message[];
+    visitArrayPattern(): Message[];
+    visitBreakStatement(): Message[];
+    visitCatchClause(): Message[];
+    visitClassBody(): Message[];
+    visitClassExpression(): Message[];
+    visitContinueStatement(): Message[];
+    visitDebuggerStatement(): Message[];
+    visitExportAllDeclaration(): Message[];
+    visitExportSpecifier(): Message[];
+    visitIdentifier(): Message[];
+    visitImportAttribute(): Message[];
+    visitImportDeclaration(): Message[];
+    visitImportDefaultSpecifier(): Message[];
+    visitImportExpression(): Message[];
+    visitImportNamespaceSpecifier(): Message[];
+    visitImportSpecifier(): Message[];
+    visitMetaProperty(): Message[];
+    visitMethodDefinition(): Message[];
+    visitPrivateIdentifier(): Message[];
+    visitPropertyDefinition(): Message[];
+    visitStaticBlock(): Message[];
+    visitSuper(): Message[];
+    visitTemplateElement(): Message[];
+    visitThisExpression(): Message[];
+    visitThrowStatement(): Message[];
+    visitUpdateExpression(): Message[];
+    visitWithStatement(): Message[];
+}

package/dist/adapter-vanilla/inertvisitors.js

@@ -0,0 +1,86 @@
+export default class {
+    visitEmptyStatement() {
+        return [];
+    }
+    visitArrayPattern() {
+        return [];
+    }
+    visitBreakStatement() {
+        return [];
+    }
+    visitCatchClause() {
+        return [];
+    }
+    visitClassBody() {
+        return [];
+    }
+    visitClassExpression() {
+        return [];
+    }
+    visitContinueStatement() {
+        return [];
+    }
+    visitDebuggerStatement() {
+        return [];
+    }
+    visitExportAllDeclaration() {
+        return [];
+    }
+    visitExportSpecifier() {
+        return [];
+    }
+    visitIdentifier() {
+        return [];
+    }
+    visitImportAttribute() {
+        return [];
+    }
+    visitImportDeclaration() {
+        return [];
+    }
+    visitImportDefaultSpecifier() {
+        return [];
+    }
+    visitImportExpression() {
+        return [];
+    }
+    visitImportNamespaceSpecifier() {
+        return [];
+    }
+    visitImportSpecifier() {
+        return [];
+    }
+    visitMetaProperty() {
+        return [];
+    }
+    visitMethodDefinition() {
+        return [];
+    } // handled inside visitClassDeclaration
+    visitPrivateIdentifier() {
+        return [];
+    }
+    visitPropertyDefinition() {
+        return [];
+    }
+    visitStaticBlock() {
+        return [];
+    } // handled inside visitClassDeclaration
+    visitSuper() {
+        return [];
+    }
+    visitTemplateElement() {
+        return [];
+    }
+    visitThisExpression() {
+        return [];
+    }
+    visitThrowStatement() {
+        return [];
+    }
+    visitUpdateExpression() {
+        return [];
+    }
+    visitWithStatement() {
+        return [];
+    }
+}