@vibe2founder/tests2dialects 0.1.0 → 0.2.0

package/dist/src/index.js

@@ -0,0 +1,374 @@
+class AtomicCore {
+    static instance;
+    rootSuite = {
+        name: "ROOT",
+        tests: [],
+        hooks: { beforeAll: [], afterAll: [], beforeEach: [], afterEach: [] },
+    };
+    currentSuite = this.rootSuite;
+    suiteStarted = new Set();
+    static get() {
+        if (!AtomicCore.instance)
+            AtomicCore.instance = new AtomicCore();
+        return AtomicCore.instance;
+    }
+    // --- Atomic Actions ---
+    defineGroup(name, fn) {
+        const parent = this.currentSuite;
+        const newSuite = {
+            name: name,
+            tests: [],
+            hooks: { beforeAll: [], afterAll: [], beforeEach: [], afterEach: [] },
+            parent,
+        };
+        this.currentSuite = newSuite;
+        try {
+            fn();
+            newSuite.hooks.afterAll.forEach((h) => h());
+        }
+        finally {
+            this.currentSuite = parent;
+        }
+    }
+    defineCase(name, fn) {
+        this.runTestSafe(this.currentSuite, name, fn);
+    }
+    addHook(type, fn) {
+        this.currentSuite.hooks[type].push(fn);
+    }
+    // --- Internal Runner Logic ---
+    async runTestSafe(suite, name, fn) {
+        // Run beforeAll if first test in this suite
+        if (!this.suiteStarted.has(suite)) {
+            suite.hooks.beforeAll.forEach((h) => h());
+            this.suiteStarted.add(suite);
+        }
+        try {
+            // Run BeforeEach hooks
+            suite.hooks.beforeEach.forEach((h) => h());
+            await fn();
+            // Run AfterEach hooks
+            suite.hooks.afterEach.forEach((h) => h());
+        }
+        catch (_e) {
+            // Handle failure silently in core, or emit event for reporter
+        }
+    }
+    reset() {
+        this.rootSuite = {
+            name: "ROOT",
+            tests: [],
+            hooks: { beforeAll: [], afterAll: [], beforeEach: [], afterEach: [] },
+        };
+        this.currentSuite = this.rootSuite;
+        this.suiteStarted.clear();
+    }
+}
+const core = AtomicCore.get();
+export const resetAtomicCore = () => core.reset();
+// ... (UniversalMockHandler, UniversalAssertion, Dialects logic remains, just update signatures if needed)
+// Using ... to represent that the rest of the file stays largely the same but with potential type updates
+// Actually I need to provide the full content or important chunks. I'll replace the whole file to be safe with types.
+// ============================================================================
+// 2. UNIVERSAL MOCK (O Ator/Dublê)
+// ============================================================================
+class UniversalMockHandler {
+    calls = [];
+    impl = null;
+    defaultReturn = undefined;
+    isResolved = false;
+    parent = null;
+    constructor(originalImpl) {
+        this.impl = originalImpl || null;
+    }
+    setParent(parent) {
+        this.parent = parent;
+    }
+    // O método que é chamado quando alguém invoca o mock
+    invoke(...args) {
+        this.calls.push(args);
+        // Notifica o pai que houve uma interação (útil para to(obj).wasCalled())
+        if (this.parent)
+            this.parent.invoke(...args);
+        if (this.impl)
+            return this.impl(...args);
+        if (this.isResolved)
+            return Promise.resolve(this.defaultReturn);
+        return this.defaultReturn;
+    }
+    // --- Setup Methods (Aliases Internos) ---
+    setReturn(val) {
+        this.defaultReturn = val;
+        this.isResolved = false;
+    }
+    setResolved(val) {
+        this.defaultReturn = val;
+        this.isResolved = true;
+    }
+    setImplementation(fn) {
+        this.impl = fn;
+    }
+    clear() {
+        this.calls = [];
+    }
+    getDefaultReturn() {
+        return this.defaultReturn;
+    }
+}
+// A função mágica que é ao mesmo tempo executável e configurável
+function createAtomicMock(implementation, parentHandler) {
+    const handler = new UniversalMockHandler(implementation);
+    if (parentHandler)
+        handler.setParent(parentHandler);
+    const subMocks = new Map();
+    const mockFn = (...args) => handler.invoke(...args);
+    // Mapeamento de TODOS os métodos de configuração de mocks
+    const config = {
+        _handler: handler,
+        // Jest
+        mockReturnValue: (v) => handler.setReturn(v),
+        mockResolvedValue: (v) => handler.setResolved(v),
+        mockImplementation: (fn) => handler.setImplementation(fn),
+        // Matemático
+        yields: (v) => handler.setReturn(v),
+        mapsTo: (v) => handler.setReturn(v),
+        convergesTo: (v) => handler.setResolved(v),
+        derive: (fn) => handler.setImplementation(fn),
+        // Narrativo
+        respondsWith: (v) => handler.setReturn(v),
+        eventuallyGives: (v) => handler.setResolved(v),
+        actsLike: (fn) => handler.setImplementation(fn),
+        // Imperativo
+        forceReturn: (v) => handler.setReturn(v),
+        resolveWith: (v) => handler.setResolved(v),
+        executes: (fn) => handler.setImplementation(fn),
+        // Common
+        clear: () => {
+            handler.clear();
+            subMocks.forEach((m) => m.clear());
+        },
+        reset: () => {
+            handler.clear();
+            handler.setImplementation(null);
+            handler.setReturn(undefined);
+            subMocks.clear();
+        },
+    };
+    // Retornamos um Proxy para permitir acesso a propriedades arbitrárias (como métodos)
+    return new Proxy(mockFn, {
+        get(target, prop) {
+            // 1. Se for um método de configuração ou propriedade interna, retorna do config
+            if (prop in config)
+                return config[prop];
+            if (prop === "then")
+                return undefined; // Evita problemas com Promises
+            // 2. Se o mock foi configurado para retornar um objeto, tentamos pegar a propriedade dele
+            const currentReturn = handler.getDefaultReturn();
+            if (currentReturn &&
+                typeof currentReturn === "object" &&
+                prop in currentReturn) {
+                return currentReturn[prop];
+            }
+            // 3. Se for uma propriedade arbitrária e não temos valor, retornamos um sub-mock (lazy creation)
+            if (!subMocks.has(prop)) {
+                subMocks.set(prop, createAtomicMock(undefined, handler));
+            }
+            return subMocks.get(prop);
+        },
+        // Permite Object.assign e outras operações
+        set(target, prop, value) {
+            config[prop] = value;
+            return true;
+        },
+    });
+}
+function createAtomicSpy(obj, method) {
+    const original = obj[method];
+    const mock = createAtomicMock(original);
+    obj[method] = mock;
+    return mock; // Retorna o mock para asserções
+}
+// ============================================================================
+// 3. UNIVERSAL ASSERTION (O Juiz)
+// ============================================================================
+class UniversalAssertion {
+    actual;
+    isNegated;
+    constructor(actual, isNegated = false) {
+        this.actual = actual;
+        this.isNegated = isNegated;
+    }
+    get not() {
+        return new UniversalAssertion(this.actual, !this.isNegated);
+    }
+    pass(condition, msg) {
+        const success = this.isNegated ? !condition : condition;
+        if (!success)
+            throw new Error(this.isNegated ? `[NOT] ${msg}` : msg);
+    }
+    // --- Equality & Truthiness ---
+    // Jest / Classic
+    toBe(expected) {
+        this.pass(this.actual === expected, `Expected ${this.actual} to be ${expected}`);
+    }
+    toEqual(expected) {
+        this.pass(JSON.stringify(this.actual) === JSON.stringify(expected), `Expected ${this.actual} to equal ${expected}`);
+    }
+    // Matemático
+    is(expected) {
+        this.toBe(expected);
+    }
+    // Narrativo
+    be(expected) {
+        this.toBe(expected);
+    }
+    // Imperativo
+    isOk() {
+        this.pass(!!this.actual, `Ensure ${this.actual} is truthy`);
+    }
+    matches(regex) {
+        if (typeof this.actual !== "string")
+            throw new Error("Value must be string");
+        this.pass(regex.test(this.actual), `Ensure '${this.actual}' matches ${regex}`);
+    }
+    // Narrativo
+    have(prop) {
+        this.pass(typeof this.actual === "object" &&
+            this.actual !== null &&
+            prop in this.actual, `Intend object to have '${prop}'`);
+    }
+    uploaded(...args) {
+        this.received(...args);
+    }
+    // --- Mock Assertions ---
+    // Helper para pegar o handler do mock
+    getMockHandler(mockFn) {
+        if (!mockFn._handler)
+            throw new Error("Assertion target is not a registered Mock/Spy function.");
+        return mockFn._handler;
+    }
+    // Jest
+    toHaveBeenCalled() {
+        const h = this.getMockHandler(this.actual);
+        this.pass(h.calls.length > 0, "Expected mock to have been called");
+    }
+    toHaveBeenCalledWith(...args) {
+        const h = this.getMockHandler(this.actual);
+        const match = h.calls.some((call) => JSON.stringify(call) === JSON.stringify(args));
+        this.pass(match, `Expected mock called with ${JSON.stringify(args)}`);
+    }
+    toHaveBeenCalledTimes(n) {
+        const h = this.getMockHandler(this.actual);
+        this.pass(h.calls.length === n, `Expected mock called ${n} times, got ${h.calls.length}`);
+    }
+    // Matemático
+    wasEvaluated() {
+        this.toHaveBeenCalled();
+    }
+    appliedTo(...args) {
+        this.toHaveBeenCalledWith(...args);
+    }
+    get evaluated() {
+        const h = this.getMockHandler(this.actual);
+        return (n) => ({ times: this.toHaveBeenCalledTimes(n) }); // Currying simulado para sintaxe .evaluated(n).times
+    }
+    // Narrativo
+    wasCalled() {
+        this.toHaveBeenCalled();
+    }
+    received(...args) {
+        this.toHaveBeenCalledWith(...args);
+    }
+    get called() {
+        const h = this.getMockHandler(this.actual);
+        return (n) => ({ times: this.toHaveBeenCalledTimes(n) });
+    }
+    // Imperativo
+    triggered() {
+        this.toHaveBeenCalled();
+    }
+    calledWith(...args) {
+        this.toHaveBeenCalledWith(...args);
+    }
+    triggeredCount(n) {
+        this.toHaveBeenCalledTimes(n);
+    }
+}
+// Factory para assertions
+const assertValue = (val) => new UniversalAssertion(val);
+// ============================================================================
+// 4. DIALECT EXPORTS (A Pedra de Roseta)
+// ============================================================================
+// --- 📐 MATEMÁTICO (MathDialect) ---
+export const MathDialect = {
+    // Structure
+    axiom: (n, f) => core.defineGroup(n, f),
+    proof: (n, f) => core.defineCase(n, f),
+    implies: assertValue,
+    // Mocks (Creation)
+    arbitrary: createAtomicMock,
+    lambda: createAtomicMock,
+    monitor: createAtomicSpy,
+    // Lifecycle
+    postulate: (f) => core.addHook("beforeAll", f),
+    conclude: (f) => core.addHook("afterAll", f),
+    given: (f) => core.addHook("beforeEach", f),
+};
+// --- 📖 NARRATIVO (NarrativeDialect) ---
+export const NarrativeDialect = {
+    // Structure
+    intend: (n, f) => core.defineGroup(n, f),
+    story: (n, f) => core.defineGroup(n, f),
+    detail: (n, f) => core.defineCase(n, f),
+    scenario: (n, f) => core.defineCase(n, f),
+    to: assertValue,
+    // Mocks (Creation)
+    dummy: createAtomicMock,
+    standIn: createAtomicMock,
+    watch: createAtomicSpy,
+    shadow: createAtomicSpy,
+    // Lifecycle
+    background: (f) => core.addHook("beforeAll", f),
+    cleanup: (f) => core.addHook("afterAll", f),
+    before: (f) => core.addHook("beforeEach", f),
+};
+// --- 🛡️ IMPERATIVO (ImperativeDialect) ---
+export const ImperativeDialect = {
+    // Structure
+    ensure: (n, f) => core.defineGroup(n, f),
+    suite: (n, f) => core.defineGroup(n, f),
+    check: (n, f) => core.defineCase(n, f),
+    verify: (n, f) => core.defineCase(n, f),
+    that: assertValue,
+    // Mocks (Creation)
+    stub: createAtomicMock,
+    mock: createAtomicMock,
+    inspect: createAtomicSpy,
+    spy: createAtomicSpy,
+    // Lifecycle
+    initAll: (f) => core.addHook("beforeAll", f),
+    disposeAll: (f) => core.addHook("afterAll", f),
+    reset: (f) => core.addHook("beforeEach", f),
+    clear: () => { }, // No-op for global clear
+};
+// --- 🤡 JEST / CLASSIC ---
+export const ClassicDialect = {
+    describe: (n, f) => core.defineGroup(n, f),
+    it: (n, f) => core.defineCase(n, f),
+    test: (n, f) => core.defineCase(n, f),
+    expect: assertValue,
+    // Objeto Jest Global (simulado)
+    jest: {
+        fn: createAtomicMock,
+        spyOn: createAtomicSpy,
+    },
+    beforeAll: (f) => core.addHook("beforeAll", f),
+    afterAll: (f) => core.addHook("afterAll", f),
+    beforeEach: (f) => core.addHook("beforeEach", f),
+    afterEach: (f) => core.addHook("afterEach", f),
+};
+// --- Top-Level Exports for Ease of Use ---
+export const { axiom, proof, implies, arbitrary, lambda, monitor, postulate, conclude, given, } = MathDialect;
+export const { intend, story, detail, scenario, to, dummy, standIn, watch, shadow, background, cleanup, before, } = NarrativeDialect;
+export const { ensure, suite, check, verify, that, stub, mock, inspect, spy, initAll, disposeAll, reset, clear, } = ImperativeDialect;
+export const { describe, it, test, expect, beforeAll, afterAll, beforeEach, afterEach, } = ClassicDialect;

package/dist/src/semantic/core.d.ts

@@ -0,0 +1,24 @@
+declare const __brand: unique symbol;
+export type Brand<T, B extends string> = T & {
+    readonly [__brand]: B;
+};
+export type Bool<Name extends string> = Brand<boolean, `bool:${Name}`>;
+export type Num<Name extends string> = Brand<number, `num:${Name}`>;
+export type Str<Name extends string> = Brand<string, `str:${Name}`>;
+export declare const STAMP: <B extends string>() => {
+    of: <T>(v: T) => Brand<T, B>;
+    un: <T>(v: Brand<T, B>) => T;
+};
+export declare const makeBool: <N extends string>(_name: N) => {
+    of: (v: boolean) => Bool<N>;
+    un: (v: Bool<N>) => boolean;
+};
+export declare const makeNum: <N extends string>(_name: N) => {
+    of: (v: number) => Num<N>;
+    un: (v: Num<N>) => number;
+};
+export declare const makeStr: <N extends string>(_name: N) => {
+    of: (v: string) => Str<N>;
+    un: (v: Str<N>) => string;
+};
+export {};

package/dist/src/semantic/core.js

@@ -0,0 +1,16 @@
+export const STAMP = () => ({
+    of: (v) => v,
+    un: (v) => v,
+});
+export const makeBool = (_name) => ({
+    of: (v) => v,
+    un: (v) => v,
+});
+export const makeNum = (_name) => ({
+    of: (v) => v,
+    un: (v) => v,
+});
+export const makeStr = (_name) => ({
+    of: (v) => v,
+    un: (v) => v,
+});

package/{types/api-types.ts → dist/types/api-types.d.ts}

@@ -1,11 +1,6 @@
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-
-export type HttpStatusCode = number; // Nominal naming implies keeping it in types folder
-
-export type ApiUrl = string;
-
-export type JsonBody = Record<string, unknown> | unknown[];
-
-export type TestName = string;
-
-export type SchemaDefinition = Record<string, unknown>;
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export type HttpStatusCode = number;
+export type ApiUrl = string;
+export type JsonBody = Record<string, unknown> | unknown[];
+export type TestName = string;
+export type SchemaDefinition = Record<string, unknown>;

package/dist/types/api-types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,36 +1,60 @@
-{
-  "name": "@vibe2founder/tests2dialects",
-  "version": "0.1.0",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "access": "public",
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "suissAI",
-  "license": "Cogfulness Ethical License (CEL) v1.0",
-  "description": "",
-  "bin": {
-    "tests2dialects": "./src/cli.ts",
-    "os4all": "./src/cli.ts",
-    "1spec": "./src/cli.ts",
-    "testall": "./src/cli.ts"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "typescript": "latest",
-    "undici-types": "latest",
-    "@types/node": "latest"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/suissa/vibe2founder-tests2dialects.git"
-  }
+{
+  "name": "@vibe2founder/tests2dialects",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "public": true,
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "access": "public",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/src/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "tests",
+    "testing",
+    "tdd",
+    "bdd",
+    "test-runner",
+    "dialects",
+    "vitest",
+    "jest",
+    "bun-test"
+  ],
+  "author": "vibe2founder",
+  "license": "Cogfulness Ethical License (CEL) v1.0",
+  "description": "Framework unificado de testes TDD/BDD com múltiplos dialetos",
+  "bin": {
+    "tests2dialects": "./src/cli.ts",
+    "os4all": "./src/cli.ts",
+    "1spec": "./src/cli.ts",
+    "testall": "./src/cli.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "latest",
+    "undici-types": "latest",
+    "@types/node": "latest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vibe2founder/tests2dialects.git"
+  },
+  "files": [
+    "dist",
+    "src",
+    "packages"
+  ]
 }