@jackwener/opencli 0.1.1 → 0.1.2

package/dist/pipeline/steps/transform.js

@@ -0,0 +1,53 @@
+/**
+ * Pipeline steps: data transforms — select, map, filter, sort, limit.
+ */
+import { render, evalExpr } from '../template.js';
+export async function stepSelect(_page, params, data, args) {
+    const pathStr = String(render(params, { args, data }));
+    if (data && typeof data === 'object') {
+        let current = data;
+        for (const part of pathStr.split('.')) {
+            if (current && typeof current === 'object' && !Array.isArray(current))
+                current = current[part];
+            else if (Array.isArray(current) && /^\d+$/.test(part))
+                current = current[parseInt(part, 10)];
+            else
+                return null;
+        }
+        return current;
+    }
+    return data;
+}
+export async function stepMap(_page, params, data, args) {
+    if (!data || typeof data !== 'object')
+        return data;
+    let items = Array.isArray(data) ? data : [data];
+    if (!Array.isArray(data) && typeof data === 'object' && 'data' in data)
+        items = data.data;
+    const result = [];
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const row = {};
+        for (const [key, template] of Object.entries(params))
+            row[key] = render(template, { args, data, item, index: i });
+        result.push(row);
+    }
+    return result;
+}
+export async function stepFilter(_page, params, data, args) {
+    if (!Array.isArray(data))
+        return data;
+    return data.filter((item, i) => evalExpr(String(params), { args, item, index: i }));
+}
+export async function stepSort(_page, params, data, _args) {
+    if (!Array.isArray(data))
+        return data;
+    const key = typeof params === 'object' ? (params.by ?? '') : String(params);
+    const reverse = typeof params === 'object' ? params.order === 'desc' : false;
+    return [...data].sort((a, b) => { const va = a[key] ?? ''; const vb = b[key] ?? ''; const cmp = va < vb ? -1 : va > vb ? 1 : 0; return reverse ? -cmp : cmp; });
+}
+export async function stepLimit(_page, params, data, args) {
+    if (!Array.isArray(data))
+        return data;
+    return data.slice(0, Number(render(params, { args, data })));
+}

package/dist/pipeline/template.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pipeline template engine: ${{ ... }} expression rendering.
+ */
+export interface RenderContext {
+    args?: Record<string, any>;
+    data?: any;
+    item?: any;
+    index?: number;
+}
+export declare function render(template: any, ctx: RenderContext): any;
+export declare function evalExpr(expr: string, ctx: RenderContext): any;
+export declare function resolvePath(pathStr: string, ctx: RenderContext): any;
+/**
+ * Normalize JavaScript source for browser evaluate() calls.
+ */
+export declare function normalizeEvaluateSource(source: string): string;

package/dist/pipeline/template.js

@@ -0,0 +1,115 @@
+/**
+ * Pipeline template engine: ${{ ... }} expression rendering.
+ */
+export function render(template, ctx) {
+    if (typeof template !== 'string')
+        return template;
+    const fullMatch = template.match(/^\$\{\{\s*(.*?)\s*\}\}$/);
+    if (fullMatch)
+        return evalExpr(fullMatch[1].trim(), ctx);
+    return template.replace(/\$\{\{\s*(.*?)\s*\}\}/g, (_m, expr) => String(evalExpr(expr.trim(), ctx)));
+}
+export function evalExpr(expr, ctx) {
+    const args = ctx.args ?? {};
+    const item = ctx.item ?? {};
+    const data = ctx.data;
+    const index = ctx.index ?? 0;
+    // Default filter: args.limit | default(20)
+    if (expr.includes('|') && expr.includes('default(')) {
+        const [mainExpr, rest] = expr.split('|', 2);
+        const defaultMatch = rest.match(/default\((.+?)\)/);
+        const defaultVal = defaultMatch ? defaultMatch[1] : null;
+        const result = resolvePath(mainExpr.trim(), { args, item, data, index });
+        if (result === null || result === undefined) {
+            if (defaultVal !== null) {
+                const intVal = parseInt(defaultVal, 10);
+                if (!isNaN(intVal) && String(intVal) === defaultVal.trim())
+                    return intVal;
+                return defaultVal.replace(/^['"]|['"]$/g, '');
+            }
+        }
+        return result;
+    }
+    // Arithmetic: index + 1
+    const arithMatch = expr.match(/^([\w][\w.]*)\s*([+\-*/])\s*(\d+)$/);
+    if (arithMatch) {
+        const [, varName, op, numStr] = arithMatch;
+        const val = resolvePath(varName, { args, item, data, index });
+        if (val !== null && val !== undefined) {
+            const numVal = Number(val);
+            const num = Number(numStr);
+            if (!isNaN(numVal)) {
+                switch (op) {
+                    case '+': return numVal + num;
+                    case '-': return numVal - num;
+                    case '*': return numVal * num;
+                    case '/': return num !== 0 ? numVal / num : 0;
+                }
+            }
+        }
+    }
+    // JS-like fallback expression: item.tweetCount || 'N/A'
+    const orMatch = expr.match(/^(.+?)\s*\|\|\s*(.+)$/);
+    if (orMatch) {
+        const left = evalExpr(orMatch[1].trim(), ctx);
+        if (left)
+            return left;
+        const right = orMatch[2].trim();
+        return right.replace(/^['"]|['"]$/g, '');
+    }
+    return resolvePath(expr, { args, item, data, index });
+}
+export function resolvePath(pathStr, ctx) {
+    const args = ctx.args ?? {};
+    const item = ctx.item ?? {};
+    const data = ctx.data;
+    const index = ctx.index ?? 0;
+    const parts = pathStr.split('.');
+    const rootName = parts[0];
+    let obj;
+    let rest;
+    if (rootName === 'args') {
+        obj = args;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'item') {
+        obj = item;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'data') {
+        obj = data;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'index')
+        return index;
+    else {
+        obj = item;
+        rest = parts;
+    }
+    for (const part of rest) {
+        if (obj && typeof obj === 'object' && !Array.isArray(obj))
+            obj = obj[part];
+        else if (Array.isArray(obj) && /^\d+$/.test(part))
+            obj = obj[parseInt(part, 10)];
+        else
+            return null;
+    }
+    return obj;
+}
+/**
+ * Normalize JavaScript source for browser evaluate() calls.
+ */
+export function normalizeEvaluateSource(source) {
+    const stripped = source.trim();
+    if (!stripped)
+        return '() => undefined';
+    if (stripped.startsWith('(') && stripped.endsWith(')()'))
+        return `() => (${stripped})`;
+    if (/^(async\s+)?\([^)]*\)\s*=>/.test(stripped))
+        return stripped;
+    if (/^(async\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=>/.test(stripped))
+        return stripped;
+    if (stripped.startsWith('function ') || stripped.startsWith('async function '))
+        return stripped;
+    return `() => (${stripped})`;
+}

package/dist/pipeline/template.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for the pipeline template engine: render, evalExpr, resolvePath.
+ */
+export {};

package/dist/pipeline/template.test.js

@@ -0,0 +1,102 @@
+/**
+ * Tests for the pipeline template engine: render, evalExpr, resolvePath.
+ */
+import { describe, it, expect } from 'vitest';
+import { render, evalExpr, resolvePath, normalizeEvaluateSource } from './template.js';
+describe('resolvePath', () => {
+    it('resolves args path', () => {
+        expect(resolvePath('args.limit', { args: { limit: 20 } })).toBe(20);
+    });
+    it('resolves nested args path', () => {
+        expect(resolvePath('args.query.keyword', { args: { query: { keyword: 'test' } } })).toBe('test');
+    });
+    it('resolves item path', () => {
+        expect(resolvePath('item.title', { item: { title: 'Hello' } })).toBe('Hello');
+    });
+    it('resolves implicit item path (no prefix)', () => {
+        expect(resolvePath('title', { item: { title: 'World' } })).toBe('World');
+    });
+    it('resolves index', () => {
+        expect(resolvePath('index', { index: 5 })).toBe(5);
+    });
+    it('resolves data path', () => {
+        expect(resolvePath('data.items', { data: { items: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('returns null for missing path', () => {
+        expect(resolvePath('args.missing', { args: {} })).toBeUndefined();
+    });
+    it('resolves array index', () => {
+        expect(resolvePath('data.0', { data: ['a', 'b'] })).toBe('a');
+    });
+});
+describe('evalExpr', () => {
+    it('evaluates default filter', () => {
+        expect(evalExpr('args.limit | default(20)', { args: {} })).toBe(20);
+    });
+    it('uses actual value over default', () => {
+        expect(evalExpr('args.limit | default(20)', { args: { limit: 10 } })).toBe(10);
+    });
+    it('evaluates string default', () => {
+        expect(evalExpr("args.name | default('unknown')", { args: {} })).toBe('unknown');
+    });
+    it('evaluates arithmetic: index + 1', () => {
+        expect(evalExpr('index + 1', { index: 0 })).toBe(1);
+    });
+    it('evaluates arithmetic: index * 2', () => {
+        expect(evalExpr('index * 2', { index: 5 })).toBe(10);
+    });
+    it('evaluates || fallback', () => {
+        expect(evalExpr("item.name || 'N/A'", { item: {} })).toBe('N/A');
+    });
+    it('evaluates || with truthy left', () => {
+        expect(evalExpr("item.name || 'N/A'", { item: { name: 'Alice' } })).toBe('Alice');
+    });
+    it('resolves simple path', () => {
+        expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
+    });
+});
+describe('render', () => {
+    it('renders full expression', () => {
+        expect(render('${{ args.limit }}', { args: { limit: 30 } })).toBe(30);
+    });
+    it('renders inline expression in string', () => {
+        expect(render('Hello ${{ item.name }}!', { item: { name: 'World' } })).toBe('Hello World!');
+    });
+    it('renders multiple inline expressions', () => {
+        expect(render('${{ item.first }}-${{ item.second }}', { item: { first: 'X', second: 'Y' } })).toBe('X-Y');
+    });
+    it('returns non-string values as-is', () => {
+        expect(render(42, {})).toBe(42);
+        expect(render(null, {})).toBeNull();
+        expect(render(undefined, {})).toBeUndefined();
+    });
+    it('returns full expression result as native type', () => {
+        expect(render('${{ args.list }}', { args: { list: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('renders URL template', () => {
+        expect(render('https://api.example.com/search?q=${{ args.keyword }}', { args: { keyword: 'test' } })).toBe('https://api.example.com/search?q=test');
+    });
+});
+describe('normalizeEvaluateSource', () => {
+    it('wraps bare expression', () => {
+        expect(normalizeEvaluateSource('document.title')).toBe('() => (document.title)');
+    });
+    it('passes through arrow function', () => {
+        expect(normalizeEvaluateSource('() => 42')).toBe('() => 42');
+    });
+    it('passes through async arrow function', () => {
+        const src = 'async () => { return 1; }';
+        expect(normalizeEvaluateSource(src)).toBe(src);
+    });
+    it('passes through named function', () => {
+        const src = 'function foo() { return 1; }';
+        expect(normalizeEvaluateSource(src)).toBe(src);
+    });
+    it('wraps IIFE pattern', () => {
+        const src = '(async () => { return 1; })()';
+        expect(normalizeEvaluateSource(src)).toBe(`() => (${src})`);
+    });
+    it('handles empty string', () => {
+        expect(normalizeEvaluateSource('')).toBe('() => undefined');
+    });
+});

package/dist/pipeline/transform.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+export {};

package/dist/pipeline/transform.test.js

@@ -0,0 +1,90 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+import { describe, it, expect } from 'vitest';
+import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
+const SAMPLE_DATA = [
+    { title: 'Alpha', score: 10, author: 'Alice' },
+    { title: 'Beta', score: 30, author: 'Bob' },
+    { title: 'Gamma', score: 20, author: 'Charlie' },
+];
+describe('stepSelect', () => {
+    it('selects nested path', async () => {
+        const data = { result: { items: [1, 2, 3] } };
+        const result = await stepSelect(null, 'result.items', data, {});
+        expect(result).toEqual([1, 2, 3]);
+    });
+    it('selects array by index', async () => {
+        const data = { list: ['a', 'b', 'c'] };
+        const result = await stepSelect(null, 'list.1', data, {});
+        expect(result).toBe('b');
+    });
+    it('returns null for missing path', async () => {
+        const result = await stepSelect(null, 'missing.path', { foo: 1 }, {});
+        expect(result).toBeNull();
+    });
+    it('returns data as-is for non-object', async () => {
+        const result = await stepSelect(null, 'foo', 'string-data', {});
+        expect(result).toBe('string-data');
+    });
+});
+describe('stepMap', () => {
+    it('maps array items', async () => {
+        const result = await stepMap(null, {
+            name: '${{ item.title }}',
+            rank: '${{ index + 1 }}',
+        }, SAMPLE_DATA, {});
+        expect(result).toEqual([
+            { name: 'Alpha', rank: 1 },
+            { name: 'Beta', rank: 2 },
+            { name: 'Gamma', rank: 3 },
+        ]);
+    });
+    it('handles single object', async () => {
+        const result = await stepMap(null, {
+            name: '${{ item.title }}',
+        }, { title: 'Solo' }, {});
+        expect(result).toEqual([{ name: 'Solo' }]);
+    });
+    it('returns null/undefined as-is', async () => {
+        expect(await stepMap(null, { x: '${{ item.x }}' }, null, {})).toBeNull();
+    });
+});
+describe('stepFilter', () => {
+    it('filters by expression', async () => {
+        const result = await stepFilter(null, 'item.score', SAMPLE_DATA, {});
+        expect(result).toHaveLength(3); // all truthy
+    });
+    it('returns non-array as-is', async () => {
+        const result = await stepFilter(null, 'item.x', 'not-array', {});
+        expect(result).toBe('not-array');
+    });
+});
+describe('stepSort', () => {
+    it('sorts ascending by key', async () => {
+        const result = await stepSort(null, 'score', SAMPLE_DATA, {});
+        expect(result.map((r) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
+    });
+    it('sorts descending', async () => {
+        const result = await stepSort(null, { by: 'score', order: 'desc' }, SAMPLE_DATA, {});
+        expect(result.map((r) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
+    });
+    it('does not mutate original', async () => {
+        const original = [...SAMPLE_DATA];
+        await stepSort(null, 'score', SAMPLE_DATA, {});
+        expect(SAMPLE_DATA).toEqual(original);
+    });
+});
+describe('stepLimit', () => {
+    it('limits array to N items', async () => {
+        const result = await stepLimit(null, '2', SAMPLE_DATA, {});
+        expect(result).toHaveLength(2);
+    });
+    it('limits using template expression', async () => {
+        const result = await stepLimit(null, '${{ args.limit }}', SAMPLE_DATA, { limit: 1 });
+        expect(result).toHaveLength(1);
+    });
+    it('returns non-array as-is', async () => {
+        expect(await stepLimit(null, '5', 'string', {})).toBe('string');
+    });
+});

package/dist/pipeline.d.ts

@@ -1,9 +1,7 @@
 /**
- * YAML pipeline executor.
- * Steps: fetch, navigate, evaluate, map, filter, sort, limit, select, snapshot, click, type, wait, press, intercept.
+ * YAML pipeline executor — re-exports from modular pipeline system.
+ *
+ * This file exists for backward compatibility. All logic has been
+ * refactored into src/pipeline/ with modular step handlers.
  */
-export interface PipelineContext {
-    args?: Record<string, any>;
-    debug?: boolean;
-}
-export declare function executePipeline(page: any, pipeline: any[], ctx?: PipelineContext): Promise<any>;
+export { executePipeline, type PipelineContext } from './pipeline/index.js';