feat: improve serialize-javascript

Author: shijistar

.gitignore

@@ -4,6 +4,8 @@ es-legacy
 umd
 tslib
 tses
+src/version.ts
+test/utils/version.ts
 types-legacy/*/*.d.ts
 node_modules
 npm-debug.log

e2e/specs/version.spec.ts

@@ -0,0 +1,4 @@
+import playwright from '../../test/engines/playwright';
+import testVersion from '../../test/test-suites/version';
+
+testVersion(playwright);

package-lock.json

@@ -115,14 +115,17 @@
   ],
   "scripts": {
     "build": "run-p build:*",
-    "build:es": "run-s task:build-es task:update-es-enum task:add-es-extensions task:add-umd-banner",
-    "build:es-legacy": "cross-env LEGACY=1 run-s task:build-es-legacy task:update-es-legacy-enum task:add-umd-banner task:add-es-legacy-extensions",
-    "build:lib": "run-s ts2lib task:copy-lib task:copy-dts task:types-legacy",
-    "build:tses": "run-s ts2es task:add-tses-extensions",
+    "build:es": "run-s gv task:build-es task:update-es-enum task:add-es-extensions task:add-umd-banner",
+    "build:es-legacy": "cross-env LEGACY=1 run-s gv task:build-es-legacy task:update-es-legacy-enum task:add-umd-banner task:add-es-legacy-extensions",
+    "build:lib": "run-s gv ts2lib task:copy-lib task:copy-dts task:types-legacy",
+    "build:tses": "run-s gv ts2es task:add-tses-extensions",
+    "clean": "shx rm -rf lib es es-legacy umd tses tslib types-legacy/pre-v5/*.d.ts",
     "e2e": "run-s task:bundle-e2e task:run-e2e",
     "e2e:debug": "run-s task:bundle-e2e task:run-e2e-debug",
     "e2e:ui": "run-s task:bundle-e2e task:run-e2e-ui",
-    "prepare": "husky",
+    "gv": "node scripts/generate-version.js",
+    "init-husky": "husky",
+    "prepare": "run-s gv init-husky",
     "prepare-legacy-node": "node ./scripts/prepare-legacy.js",
     "prepublishOnly": "run-s build test-all",
     "task:add-es-extensions": "tsx scripts/add-esm-extensions.ts es",
@@ -147,8 +150,8 @@
     "task:update-tses-enum": "tsx scripts/update-enum-ts.ts tses",
     "test": "npm run task:jest",
     "test-all": "run-s task:jest test-node-cjs test-node-esm e2e",
-    "test-node-cjs": "run-s ts2lib task:jest-cjs",
-    "test-node-esm": "run-s build:tses task:jest-esm",
+    "test-node-cjs": "run-s build:lib ts2lib task:jest-cjs",
+    "test-node-esm": "run-s build:es build:tses task:jest-esm",
     "ts2es": "tsc -p tsconfig.es.json",
     "ts2lib": "tsc -p tsconfig.lib.json"
   },

package.json

@@ -21,7 +21,7 @@ function processDir(dir: string) {
     } else if (file.endsWith('.js')) {
       let content = readFileSync(fullPath, 'utf8');
       content = content.replace(/from\s+(['"])([./][^'"]+)['"]/g, (match, quote, importPath) => {
-        if (!importPath.endsWith('.js')) {
+        if (!importPath.endsWith('.js') && !importPath.endsWith('.json')) {
           return `from ${quote}${importPath}.js${quote}`;
         }
         return match;

scripts/add-esm-extensions.ts

@@ -0,0 +1,34 @@
+const path = require('path');
+const fs = require('fs');
+
+const root = path.resolve(__dirname, '..');
+
+generate(path.join(root, 'src/version.ts'));
+generate(path.join(root, 'test/utils/version.ts'));
+
+/** @param {string} outFile */
+function generate(outFile) {
+  try {
+    const pkgPath = path.join(root, 'package.json');
+    const pkgRaw = fs.readFileSync(pkgPath, 'utf8');
+    const pkg = JSON.parse(pkgRaw);
+    const version = pkg.version;
+    if (!version || typeof version !== 'string') {
+      throw new Error('Missing version field in package.json');
+    }
+
+    const content = `export const version = '${version}';\n`;
+
+    if (fs.existsSync(outFile)) {
+      const existing = fs.readFileSync(outFile, 'utf8');
+      if (existing !== content) {
+        fs.writeFileSync(outFile, content, 'utf8');
+      }
+    } else {
+      fs.writeFileSync(outFile, content, 'utf8');
+    }
+  } catch (err) {
+    console.error('Error generating version.ts:', err);
+    process.exitCode = 1;
+  }
+}

scripts/generate-version.js

@@ -1,5 +1,4 @@
 import { nodeResolve } from '@rollup/plugin-node-resolve';
-import { cpSync, readFileSync, writeFileSync } from 'fs';
 import { rollup } from 'rollup';
 
 async function build() {
@@ -26,60 +25,40 @@ async function build() {
   });
 
   // Bundle serialize-javascript
-  const serializePath = './e2e/fixtures/scripts/serialize-javascript.js';
-  changeFormat('./tslib/test/utils/serialize-javascript.js', serializePath, 'SerializeJavascript');
   const serializeJavascript = await rollup({
-    input: serializePath,
+    input: 'tses/test/utils/serialize-javascript.js',
     plugins: [nodeResolve()],
   });
   await serializeJavascript.write({
     file: 'e2e/fixtures/scripts/serialize-javascript-bundle.js',
     format: 'iife',
+    name: 'SerializeJavascript',
   });
 
   // Bundle week-config
-  const weekConfigPath = './e2e/fixtures/scripts/week-config.js';
-  changeFormat('./tslib/test/data/week-config.js', weekConfigPath, 'WeekConfig', (content) => {
-    return content.replace('require("../src")', 'window.EnumPlus');
-  });
   const weekConfig = await rollup({
-    input: weekConfigPath,
+    input: 'tses/test/data/week-config.js',
     plugins: [nodeResolve()],
   });
   await weekConfig.write({
     file: 'e2e/fixtures/scripts/week-config-bundle.js',
     format: 'iife',
+    name: 'WeekConfig',
   });
 
   // Bundle week-data
-  const weekDataPath = './e2e/fixtures/scripts/week-data.js';
-  changeFormat('./tslib/test/data/week-data.js', weekDataPath, 'WeekData');
   const weekDataConfig = await rollup({
-    input: weekDataPath,
+    input: 'tses/test/data/week-data.js',
     plugins: [nodeResolve()],
   });
   await weekDataConfig.write({
     file: 'e2e/fixtures/scripts/week-data-bundle.js',
     format: 'iife',
+    name: 'WeekData',
   });
 }
 
 build().catch((e) => {
   console.error(e);
   process.exit(1);
 });
-
-function changeFormat(src: string, dest: string, name: string, replacer?: (content: string) => string) {
-  cpSync(src, dest, {
-    force: true,
-  });
-  let content = readFileSync(dest, 'utf-8');
-  content = `var exports = {};\n` + content;
-  if (name) {
-    content += `\n window.${name} = exports;`;
-  }
-  if (replacer) {
-    content = replacer(content);
-  }
-  writeFileSync(dest, content);
-}

scripts/make-e2e-bundle.ts

@@ -17,6 +17,7 @@ export type { ToListConfig, IEnumItems } from './enum-items';
 export type { EnumItemClass, EnumItemOptions } from './enum-item';
 export type { IEnum, EnumInterface, EnumInitOptions } from './enum';
 
+export { version } from './version';
 export { KEYS, ITEMS, VALUES, LABELS, META, IS_ENUM_ITEM, IS_ENUM_ITEMS, IS_ENUM, defaultLocalize } from './utils';
 export type { PluginFunc } from './enum';
 export { Enum } from './enum';

src/index.ts

@@ -64,8 +64,8 @@ export class PlaywrightEngine extends TestEngineBase {
         SerializeJavascript,
       };
       // console.log('window', runtimeContext);
-      const { stringify: serialize, parse: deserialize } = SerializeJavascript;
-      const args = deserialize(contextStr) as { evaluateFn: (context: RuntimeContext) => Data };
+      const { stringify, parse } = SerializeJavascript;
+      const args = parse(contextStr) as { evaluateFn: (context: RuntimeContext) => Data };
       const { evaluateFn, ...rest } = args;
 
       // Set the initial state to en-US before executing evaluation, equal to setup in jest.
@@ -77,7 +77,7 @@ export class PlaywrightEngine extends TestEngineBase {
       // console.log(evaluateResult);
 
       // Serialize the evaluation result and pass it to assertion method
-      const serializedStr = serialize({
+      const serializedStr = stringify({
         _enumLocalize: EnumPlus.Enum.localize,
         _lang: WeekConfig.lang,
         ...evaluateResult,

test/engines/playwright.ts

@@ -35,7 +35,6 @@ const testEnumCollection = (engine: TestEngineBase) => {
         engine.expect(week.label(1)).toBe(week.items.label(1));
         engine.expect(week.key(1)).toBe(week.items.key(1));
         engine.expect(week.has(1)).toBe(week.items.has(1));
-        console.log(week.findBy('key', 'Monday') === week.items.findBy('key', 'Monday'));
         engine.expect(week.findBy('key', 'Monday')).toBe(week.items.findBy('key', 'Monday'));
         engine.expect(week.findBy('value', 1)).toEqual(week.items.findBy('value', 1));
         engine.expect(week.findBy('label', 'weekday.monday')).toEqual(week.items.findBy('label', 'weekday.monday'));
@@ -70,7 +69,7 @@ const testEnumCollection = (engine: TestEngineBase) => {
 
         const strangerEnumConfig = {
           ...strangeEnumConfig,
-          items: { value: 101, label: 'bar' },
+          items: { value: 100, label: 'bar' },
         } as const;
         const strangerEnum = Enum(strangerEnumConfig);
         return {
@@ -132,7 +131,7 @@ const testEnumCollection = (engine: TestEngineBase) => {
         });
         engine.expect(strangeEnum.items.toValueMap()).toEqual(map);
 
-        engine.expect(strangerEnum.items).toBe(101);
+        engine.expect(strangerEnum.items).toBe(100);
         const standardEnumItems = Object.keys(strangerEnumConfig).map((key) => ({
           key,
           value: strangerEnumConfig[key as keyof typeof strangerEnumConfig].value,