@wexample/js-pseudocode 0.1.0

package/src/lib/Config/DocCommentConfig.ts

@@ -0,0 +1,54 @@
+import type { FunctionParameterConfig } from './FunctionParameterConfig.ts';
+import type { FunctionReturnConfig } from './FunctionReturnConfig.ts';
+
+export class DocCommentConfig {
+  description: string | null;
+  parameters: FunctionParameterConfig[];
+  return: FunctionReturnConfig | null;
+
+  constructor({
+    description = null,
+    parameters = [],
+    returnConfig = null,
+  }: {
+    description?: string | null;
+    parameters?: FunctionParameterConfig[];
+    returnConfig?: FunctionReturnConfig | null;
+  }) {
+    this.description = description ?? null;
+    this.parameters = parameters;
+    this.return = returnConfig ?? null;
+  }
+
+  static buildJSDoc({
+    description,
+    parameters,
+    returnConfig,
+  }: {
+    description?: string | null;
+    parameters: FunctionParameterConfig[];
+    returnConfig: FunctionReturnConfig | null;
+  }): string {
+    const lines: string[] = ['/**'];
+    if (description) {
+      for (const line of description.split('\n')) {
+        lines.push(` * ${line}`);
+      }
+    }
+    const paramLines: string[] = [];
+    for (const p of parameters) {
+      const desc = p.description ? ` - ${p.description}` : '';
+      paramLines.push(` * @param ${p.name}${desc}`);
+    }
+    const retDesc = returnConfig && returnConfig.description ? ` ${returnConfig.description}` : '';
+    if (paramLines.length || returnConfig) {
+      if (description) {
+        lines.push(' *');
+      }
+      for (const l of paramLines) lines.push(l);
+      if (returnConfig) lines.push(` * @returns${retDesc ? ':' + retDesc : ''}`);
+    }
+    lines.push(' */');
+    return lines.join('\n');
+  }
+}

package/src/lib/Config/FunctionConfig.ts

@@ -0,0 +1,56 @@
+import { DocCommentConfig } from './DocCommentConfig.ts';
+import { FunctionParameterConfig } from './FunctionParameterConfig.ts';
+import { FunctionReturnConfig } from './FunctionReturnConfig.ts';
+
+export class FunctionConfig {
+  type = 'function' as const;
+  name: string;
+  description: string | null;
+  parameters: FunctionParameterConfig[];
+  return: FunctionReturnConfig | null;
+
+  constructor({
+    name,
+    description,
+    parameters,
+    returnConfig,
+  }: {
+    name: string;
+    description?: string | null;
+    parameters?: FunctionParameterConfig[];
+    returnConfig?: FunctionReturnConfig | null;
+  }) {
+    this.name = name;
+    this.description = description || null;
+    this.parameters = parameters || [];
+    this.return = returnConfig || null;
+  }
+
+  static fromConfig(data: any): FunctionConfig {
+    const params = Array.isArray(data.parameters)
+      ? data.parameters.map((p: any) => FunctionParameterConfig.fromConfig(p))
+      : [];
+    const ret = FunctionReturnConfig.fromConfig(data.return);
+    return new FunctionConfig({
+      name: data.name,
+      description: data.description,
+      parameters: params,
+      returnConfig: ret,
+    });
+  }
+
+  toCode(): string {
+    const paramsSrc = this.parameters.map((p) => p.toCode()).join(', ');
+    const jsdoc = DocCommentConfig.buildJSDoc({
+      description: this.description,
+      parameters: this.parameters,
+      returnConfig: this.return,
+    });
+    const lines: string[] = [];
+    if (jsdoc) lines.push(jsdoc);
+    lines.push(`function ${this.name}(${paramsSrc}) {`);
+    lines.push(`  // TODO: Implement function body`);
+    lines.push(`}`);
+    return lines.join('\n');
+  }
+}

package/src/lib/Config/FunctionParameterConfig.ts

@@ -0,0 +1,41 @@
+export class FunctionParameterConfig {
+  name: string;
+  type: string | null;
+  description: string | null;
+  optional: boolean;
+  defaultValue: unknown;
+
+  constructor({
+    name,
+    type,
+    description,
+    optional = false,
+    defaultValue = undefined,
+  }: {
+    name: string;
+    type?: string | null;
+    description?: string | null;
+    optional?: boolean;
+    defaultValue?: unknown;
+  }) {
+    this.name = name;
+    this.type = type || null;
+    this.description = description || null;
+    this.optional = !!optional;
+    this.defaultValue = defaultValue;
+  }
+
+  static fromConfig(data: any): FunctionParameterConfig {
+    return new FunctionParameterConfig({
+      name: data.name,
+      type: data.type,
+      description: data.description,
+      optional: data.optional,
+      defaultValue: data.default,
+    });
+  }
+
+  toCode(): string {
+    return this.name;
+  }
+}

package/src/lib/Config/FunctionReturnConfig.ts

@@ -0,0 +1,20 @@
+export class FunctionReturnConfig {
+  type: string | null;
+  description: string | null;
+
+  constructor({ type, description }: { type?: string | null; description?: string | null }) {
+    this.type = type || null;
+    this.description = description || null;
+  }
+
+  static fromConfig(data: any): FunctionReturnConfig | null {
+    if (!data) return null;
+    if (typeof data !== 'object') {
+      throw new Error('Invalid YAML for return: expected mapping with key "type"');
+    }
+    if (!('type' in data) || !data.type) {
+      throw new Error('Invalid YAML for return: missing non-empty "type"');
+    }
+    return new FunctionReturnConfig({ type: data.type, description: data.description });
+  }
+}

package/src/lib/Generator/CodeGenerator.ts

@@ -0,0 +1,36 @@
+import yaml from 'js-yaml';
+import { ClassConfig } from '../Config/ClassConfig.ts';
+import { ConstantConfig } from '../Config/ConstantConfig.ts';
+import { FunctionConfig } from '../Config/FunctionConfig.ts';
+
+export class CodeGenerator {
+  generate(yamlText: string): string {
+    const data = yaml.load(yamlText) as any;
+    if (!data || !Array.isArray(data.items)) {
+      throw new Error('Invalid YAML: expected root with items[]');
+    }
+    const parts: string[] = [];
+    for (const item of data.items) {
+      switch (item.type) {
+        case 'constant': {
+          const cfg = ConstantConfig.fromConfig(item);
+          parts.push(cfg.toCode());
+          break;
+        }
+        case 'function': {
+          const cfg = FunctionConfig.fromConfig(item);
+          parts.push(cfg.toCode());
+          break;
+        }
+        case 'class': {
+          const cfg = ClassConfig.fromConfig(item);
+          parts.push(cfg.toCode());
+          break;
+        }
+        default:
+          throw new Error(`Unsupported item type: ${item.type}`);
+      }
+    }
+    return parts.join('\n');
+  }
+}

package/tests/class_basic_calculator.test.js

@@ -0,0 +1,48 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodeGenerator } from '../src/index.js';
+
+const pyFixtureDir =
+  '/home/weeger/Desktop/WIP/WEB/WEXAMPLE/PIP/pip/pseudocode/tests/resources/item/class';
+
+function normalizeEol(s) {
+  return s.replace(/\r\n/g, '\n');
+}
+
+const expectedJs = normalizeEol(`/**
+ * A class that performs basic arithmetic operations.
+ */
+class Calculator {
+  constructor() {
+    // Stores the result of the last operation performed.
+    this.lastResult = 0;
+  }
+  /**
+   * Calculate the sum of two ints.
+   *
+   * @param a - The first operand.
+   * @param b - The second operand.
+   * @returns: The sum of the two numbers.
+   */
+  add(a, b) {
+    // TODO: Implement method body
+  }
+}`);
+
+function assertEqual(a, b, msg) {
+  if (a !== b) {
+    console.error('Assertion failed:', msg || 'values differ');
+    console.error('Expected:\n' + b);
+    console.error('Actual:\n' + a);
+    process.exit(1);
+  }
+}
+
+const yml = readFileSync(join(pyFixtureDir, 'basic_calculator.yml'), 'utf-8');
+const code = new CodeGenerator().generate(yml);
+assertEqual(
+  normalizeEol(code.trim()),
+  expectedJs,
+  'YAML -> JS class generation matches expected JS'
+);
+console.log('OK');

package/tests/class_basic_calculator.test.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodeGenerator } from '../src/index.ts';
+import { normalizeEol, readExpected } from './utils/testHelpers.ts';
+
+const resDir = join(process.cwd(), 'tests', 'resources', 'item', 'class');
+
+const expectedJs = readExpected(join(resDir, 'basic_calculator.js.txt'));
+
+function assertEqual(a: string, b: string, msg?: string) {
+  if (a !== b) {
+    console.error('Assertion failed:', msg || 'values differ');
+    console.error('Expected:\n' + b);
+    console.error('Actual:\n' + a);
+    process.exit(1);
+  }
+}
+
+const yml = readFileSync(join(resDir, 'basic_calculator.yml'), 'utf-8');
+const code = new CodeGenerator().generate(yml);
+assertEqual(
+  normalizeEol(code.trim()),
+  expectedJs,
+  'YAML -> JS class generation matches expected JS'
+);
+console.log('OK');

package/tests/constant_using_const.test.js

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodeGenerator } from '../src/index.js';
+
+const phpFixtureDir =
+  '/home/weeger/Desktop/WIP/WEB/WEXAMPLE/COMPOSER/packages/wexample/php-pseudocode/tests/resources/item/constant';
+
+function normalizeEol(s) {
+  return s.replace(/\r\n/g, '\n');
+}
+
+const expectedJs = normalizeEol(`// Maximum number of retries for API calls
+const MAX_RETRIES = 3;
+// Base URL for the API
+const API_BASE_URL = "https://api.example.com";`);
+
+function assertEqual(a, b, msg) {
+  if (a !== b) {
+    console.error('Assertion failed:', msg || 'values differ');
+    console.error('Expected:\n' + b);
+    console.error('Actual:\n' + a);
+    process.exit(1);
+  }
+}
+
+const yml = readFileSync(join(phpFixtureDir, 'constant_using_const.yml'), 'utf-8');
+const code = new CodeGenerator().generate(yml);
+assertEqual(
+  normalizeEol(code.trim()),
+  expectedJs,
+  'YAML -> JS constants generation matches expected JS'
+);
+console.log('OK');

package/tests/constant_using_const.test.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodeGenerator } from '../src/index.ts';
+import { normalizeEol, readExpected } from './utils/testHelpers.ts';
+
+const resDir = join(process.cwd(), 'tests', 'resources', 'item', 'constant');
+
+const expectedJs = readExpected(join(resDir, 'constant_using_const.js.txt'));
+
+function assertEqual(a: string, b: string, msg?: string) {
+  if (a !== b) {
+    console.error('Assertion failed:', msg || 'values differ');
+    console.error('Expected:\n' + b);
+    console.error('Actual:\n' + a);
+    process.exit(1);
+  }
+}
+
+const yml = readFileSync(join(resDir, 'constant_using_const.yml'), 'utf-8');
+const code = new CodeGenerator().generate(yml);
+assertEqual(
+  normalizeEol(code.trim()),
+  expectedJs,
+  'YAML -> JS constants generation matches expected JS'
+);
+console.log('OK');

package/tests/function_basic.test.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodeGenerator } from '../src/index.js';
+
+const pyFixtureDir =
+  '/home/weeger/Desktop/WIP/WEB/WEXAMPLE/PIP/pip/pseudocode/tests/resources/item/function';
+
+function normalizeEol(s) {
+  return s.replace(/\r\n/g, '\n');
+}
+
+const expectedJs = normalizeEol(`/**
+ * Calculate the sum of two ints.
+ *
+ * @param a - The first operand.
+ * @param b - The second operand.
+ * @returns: The sum of the two numbers.
+ */
+function add(a, b) {
+  // TODO: Implement function body
+}`);
+
+function assertEqual(a, b, msg) {
+  if (a !== b) {
+    console.error('Assertion failed:', msg || 'values differ');
+    console.error('Expected:\n' + b);
+    console.error('Actual:\n' + a);
+    process.exit(1);
+  }
+}
+
+const yml = readFileSync(join(pyFixtureDir, 'basic_function.yml'), 'utf-8');
+const code = new CodeGenerator().generate(yml);
+assertEqual(
+  normalizeEol(code.trim()),
+  expectedJs,
+  'YAML -> JS function generation matches expected JS'
+);
+console.log('OK');

package/tests/function_basic.test.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodeGenerator } from '../src/index.ts';
+import { normalizeEol, readExpected } from './utils/testHelpers.ts';
+
+const resDir = join(process.cwd(), 'tests', 'resources', 'item', 'function');
+
+const expectedJs = readExpected(join(resDir, 'basic_function.js.txt'));
+
+function assertEqual(a: string, b: string, msg?: string) {
+  if (a !== b) {
+    console.error('Assertion failed:', msg || 'values differ');
+    console.error('Expected:\n' + b);
+    console.error('Actual:\n' + a);
+    process.exit(1);
+  }
+}
+
+const yml = readFileSync(join(resDir, 'basic_function.yml'), 'utf-8');
+const code = new CodeGenerator().generate(yml);
+assertEqual(
+  normalizeEol(code.trim()),
+  expectedJs,
+  'YAML -> JS function generation matches expected JS'
+);
+console.log('OK');

package/tests/function_complex.test.js

@@ -0,0 +1,40 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodeGenerator } from '../src/index.js';
+
+const pyFixtureDir =
+  '/home/weeger/Desktop/WIP/WEB/WEXAMPLE/PIP/pip/pseudocode/tests/resources/item/function';
+
+function normalizeEol(s) {
+  return s.replace(/\r\n/g, '\n');
+}
+
+const expectedJs = normalizeEol(`/**
+ * Process an array of data with optional configuration.
+ *
+ * @param data - The data to process
+ * @param config - Optional configuration parameters
+ * @param callback - Optional callback for custom processing
+ * @returns
+ */
+function processData(data, config, callback) {
+  // TODO: Implement function body
+}`);
+
+function assertEqual(a, b, msg) {
+  if (a !== b) {
+    console.error('Assertion failed:', msg || 'values differ');
+    console.error('Expected:\n' + b);
+    console.error('Actual:\n' + a);
+    process.exit(1);
+  }
+}
+
+const yml = readFileSync(join(pyFixtureDir, 'complex_function.yml'), 'utf-8');
+const code = new CodeGenerator().generate(yml);
+assertEqual(
+  normalizeEol(code.trim()),
+  expectedJs,
+  'YAML -> JS complex function generation matches expected JS'
+);
+console.log('OK');

package/tests/function_complex.test.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodeGenerator } from '../src/index.ts';
+import { normalizeEol, readExpected } from './utils/testHelpers.ts';
+
+const resDir = join(process.cwd(), 'tests', 'resources', 'item', 'function');
+
+const expectedJs = readExpected(join(resDir, 'complex_function.js.txt'));
+
+function assertEqual(a: string, b: string, msg?: string) {
+  if (a !== b) {
+    console.error('Assertion failed:', msg || 'values differ');
+    console.error('Expected:\n' + b);
+    console.error('Actual:\n' + a);
+    process.exit(1);
+  }
+}
+
+const yml = readFileSync(join(resDir, 'complex_function.yml'), 'utf-8');
+const code = new CodeGenerator().generate(yml);
+assertEqual(
+  normalizeEol(code.trim()),
+  expectedJs,
+  'YAML -> JS complex function generation matches expected JS'
+);
+console.log('OK');

package/tests/resources/item/class/basic_calculator.js.txt

@@ -0,0 +1,19 @@
+/**
+ * A class that performs basic arithmetic operations.
+ */
+class Calculator {
+  constructor() {
+    // Stores the result of the last operation performed.
+    this.lastResult = 0;
+  }
+  /**
+   * Calculate the sum of two ints.
+   *
+   * @param a - The first operand.
+   * @param b - The second operand.
+   * @returns: The sum of the two numbers.
+   */
+  add(a, b) {
+    // TODO: Implement method body
+  }
+}

package/tests/resources/item/class/basic_calculator.yml

@@ -0,0 +1,23 @@
+items:
+  - name: Calculator
+    type: class
+    description: "A class that performs basic arithmetic operations."
+    properties:
+      - name: lastResult
+        type: int
+        description: "Stores the result of the last operation performed."
+        default: 0
+    methods:
+      - type: method
+        name: add
+        description: "Calculate the sum of two ints."
+        parameters:
+          - type: int
+            name: a
+            description: 'The first operand.'
+          - type: int
+            name: b
+            description: "The second operand."
+        return:
+          type: int
+          description: "The sum of the two numbers."

package/tests/resources/item/constant/constant_using_const.js.txt

@@ -0,0 +1,4 @@
+// Maximum number of retries for API calls
+const MAX_RETRIES = 3;
+// Base URL for the API
+const API_BASE_URL = "https://api.example.com";

package/tests/resources/item/constant/constant_using_const.yml

@@ -0,0 +1,16 @@
+generator:
+  php:
+    constantDeclaration: "const"
+
+items:
+  - type: constant
+    name: MAX_RETRIES
+    value: 3
+    description: "Maximum number of retries for API calls"
+  - type: constant
+    name: API_BASE_URL
+    value: "https://api.example.com"
+    description: "Base URL for the API"
+    generator:
+      php:
+        constantDeclaration: "define"

package/tests/resources/item/constant/constant_using_define.yml

@@ -0,0 +1,16 @@
+generator:
+  php:
+    constantDeclaration: "define"
+
+items:
+  - type: constant
+    name: PI
+    value: 3.14159
+    description: "Mathematical constant for circle calculations."
+  - type: constant
+    name: DEFAULT_GREETING
+    value: "Hello, World!"
+    description: "Default greeting message."
+    generator:
+      php:
+        constantDeclaration: "const"

package/tests/resources/item/function/basic_function.js.txt

@@ -0,0 +1,10 @@
+/**
+ * Calculate the sum of two ints.
+ *
+ * @param a - The first operand.
+ * @param b - The second operand.
+ * @returns: The sum of the two numbers.
+ */
+function add(a, b) {
+  // TODO: Implement function body
+}

package/tests/resources/item/function/basic_function.yml

@@ -0,0 +1,14 @@
+items:
+  - type: function
+    name: add
+    description: "Calculate the sum of two ints."
+    parameters:
+      - name: a
+        type: int
+        description: "The first operand."
+      - name: b
+        type: int
+        description: "The second operand."
+    return:
+      type: int
+      description: "The sum of the two numbers."

package/tests/resources/item/function/complex_function.js.txt

@@ -0,0 +1,11 @@
+/**
+ * Process an array of data with optional configuration.
+ *
+ * @param data - The data to process
+ * @param config - Optional configuration parameters
+ * @param callback - Optional callback for custom processing
+ * @returns
+ */
+function processData(data, config, callback) {
+  // TODO: Implement function body
+}

package/tests/resources/item/function/complex_function.yml

@@ -0,0 +1,19 @@
+items:
+  - type: function
+    name: processData
+    description: "Process an array of data with optional configuration."
+    parameters:
+      - name: data
+        type: array
+        description: "The data to process"
+      - name: config
+        type: array
+        description: "Optional configuration parameters"
+        default: []
+      - name: callback
+        type: callable
+        description: "Optional callback for custom processing"
+        optional: true
+        default: null
+    return:
+      type: array

package/tests/utils/testHelpers.ts

@@ -0,0 +1,9 @@
+import { readFileSync } from 'node:fs';
+
+export function normalizeEol(s: string): string {
+  return s.replace(/\r\n/g, '\n');
+}
+
+export function readExpected(filePath: string): string {
+  return normalizeEol(readFileSync(filePath, 'utf-8')).trim();
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true
+  },
+  "include": ["src", "tests"]
+}

package/version.txt

@@ -0,0 +1 @@
+0.1.0