ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ವೈಟ್‌ನ ವರ್ಗ ಕ್ಷೇತ್ರ ರೂಪಾಂತರವನ್ನು ತಪ್ಪಿಸುವುದು

ತಡೆರಹಿತ ಏಕೀಕರಣಕ್ಕಾಗಿ ವೈಟ್‌ನಲ್ಲಿ ವರ್ಗ ಕ್ಷೇತ್ರ ರೂಪಾಂತರಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

Vite ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಗೆ ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ, ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ವೇಗವಾದ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇತರ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಘರ್ಷಣೆಯಾಗುವ ರೀತಿಯಲ್ಲಿ Vite ಕೋಡ್ ಅನ್ನು ಪರಿವರ್ತಿಸಿದಾಗ ಡೆವಲಪರ್‌ಗಳು ಕೆಲವೊಮ್ಮೆ ಸವಾಲುಗಳನ್ನು ಎದುರಿಸಬಹುದು. ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ವರ್ಗ ಕ್ಷೇತ್ರಗಳು ರೂಪಾಂತರಗೊಂಡಾಗ ಅಂತಹ ಒಂದು ಸಮಸ್ಯೆ ಉದ್ಭವಿಸುತ್ತದೆ.

ಫೌಂಡ್ರಿವಿಟಿಟಿ ಸಿಸ್ಟಮ್‌ನಂತಹ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳೊಂದಿಗೆ ಔಟ್‌ಪುಟ್ ಸರಾಗವಾಗಿ ಸಂಯೋಜಿಸಬೇಕಾದಾಗ ಈ ರೂಪಾಂತರವು ವಿಶೇಷವಾಗಿ ಸಮಸ್ಯಾತ್ಮಕವಾಗಿರುತ್ತದೆ. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಈ ರೂಪಾಂತರಗಳು ಘರ್ಷಣೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತವೆ, ಇದು ವರ್ಗ ಕ್ಷೇತ್ರಗಳ ಪ್ರಾರಂಭವನ್ನು ಅಡ್ಡಿಪಡಿಸುತ್ತದೆ, ಇದು ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಿಸ್ತರಣೆಗಳು ಅಥವಾ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಬಳಸುವ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ವರ್ಗ ಕ್ಷೇತ್ರಗಳನ್ನು ವೈಟ್ ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ನಿಯಂತ್ರಿಸುವುದು ಅತ್ಯಗತ್ಯ. ವರ್ಗ ಕ್ಷೇತ್ರಗಳನ್ನು ಕಸ್ಟಮ್ ಗುಣಲಕ್ಷಣಗಳಾಗಿ ಪರಿವರ್ತಿಸುವ ಡೀಫಾಲ್ಟ್ ನಡವಳಿಕೆಯು ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ನೀವು ನಿರ್ಮಿಸುತ್ತಿರುವ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಟ್ಟುನಿಟ್ಟಾದ ಆಂತರಿಕ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಹೊಂದಿದ್ದರೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ವೈಟ್‌ನ ವರ್ಗ ಕ್ಷೇತ್ರ ರೂಪಾಂತರಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು, ಈ ಬದಲಾವಣೆಗಳನ್ನು ತಪ್ಪಿಸುವ ಹಿಂದಿನ ಪ್ರೇರಣೆಗಳನ್ನು ಚರ್ಚಿಸುವುದು ಮತ್ತು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಕೆಲವು ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು ಹೇಗೆ ಎಂದು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ಈ ಸಂಘರ್ಷಗಳನ್ನು ಪರಿಹರಿಸುವ ಮೂಲಕ, ನೀವು FoundryVTT ನಂತಹ ಬಾಹ್ಯ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ವೈಟ್ ಕ್ಲಾಸ್ ಫೀಲ್ಡ್ ರೂಪಾಂತರಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ, ಫೌಂಡ್ರಿವಿಟಿಟಿಯಂತಹ ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಘರ್ಷಣೆಯನ್ನು ಉಂಟುಮಾಡುವ ರೀತಿಯಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವರ್ಗ ಕ್ಷೇತ್ರಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದನ್ನು ತಡೆಯಲು ವೈಟ್‌ನ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಿಹೊಂದಿಸುವುದರ ಮೇಲೆ ಗಮನ ಕೇಂದ್ರೀಕರಿಸಲಾಗಿದೆ. ಪರಿಹಾರದ ಪ್ರಮುಖ ಭಾಗಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ DefineForClassFields ಅನ್ನು ಬಳಸಿ ನಲ್ಲಿ ಸೆಟ್ಟಿಂಗ್ jsconfig.json ಕಡತ. ಈ ಆಜ್ಞೆಯು JavaScript ವರ್ಗ ಕ್ಷೇತ್ರಗಳನ್ನು ಹೇಗೆ ಕಂಪೈಲ್ ಮಾಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ತಪ್ಪು ಎಂದು ಹೊಂದಿಸುವ ಮೂಲಕ ನಾವು Object.defineProperty ಅನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸುತ್ತೇವೆ, ಇದು ವರ್ಗ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸಬೇಕೆಂದು FoundryVTT ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಎಂಬುದರಲ್ಲಿ ಹಸ್ತಕ್ಷೇಪ ಮಾಡಬಹುದು. ಈ ವಿಧಾನವು ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಪರಿಹಾರದ ಮತ್ತೊಂದು ಮಹತ್ವದ ಭಾಗವು ಬಿಲ್ಡ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ vite.config.js ಕಡತ. ಸಂರಚನೆಯು ಆಜ್ಞೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಸಂರಕ್ಷಿಸಿ ಮತ್ತು entryFileNames. ದಿ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಸಂರಕ್ಷಿಸಿ ನಿರ್ಮಾಣದ ಸಮಯದಲ್ಲಿ Vite ಮಾಡ್ಯೂಲ್ ರಚನೆಯನ್ನು ಚಪ್ಪಟೆಗೊಳಿಸುವುದಿಲ್ಲ ಎಂದು ಆಜ್ಞೆಯು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು ಪ್ಲಗಿನ್‌ಗಳು ಅಥವಾ ಲೈಬ್ರರಿಗಳಂತಹ ಮಾಡ್ಯೂಲ್ ಗಡಿಗಳನ್ನು ಅವಲಂಬಿಸಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಮುಖ್ಯವಾಗಿದೆ. ದಿ entryFileNames ಆಯ್ಕೆಯನ್ನು ನಂತರ ರಚಿಸಲಾದ ಫೈಲ್‌ಗಳ ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯವನ್ನು ನಿಯಂತ್ರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ಅವುಗಳು ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ರೀತಿಯಲ್ಲಿ ರಚನೆಯಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತವೆ, ಸಂಭಾವ್ಯ ಸಂಘರ್ಷಗಳನ್ನು ತಪ್ಪಿಸುತ್ತವೆ.

ಜೊತೆಗೆ, ಪರಿಹಾರವು ಸಂಯೋಜಿಸುತ್ತದೆ @babel/plugin-syntax-class-properties ವರ್ಗ ಕ್ಷೇತ್ರಗಳನ್ನು ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣ ಅಗತ್ಯವಿದ್ದರೆ ಪ್ಲಗಿನ್. ಈ ಬಾಬೆಲ್ ಪ್ಲಗಿನ್ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅವುಗಳ ಬಳಕೆಯನ್ನು ಅನುಮತಿಸುವಾಗ ವರ್ಗ ಗುಣಲಕ್ಷಣಗಳ ರೂಪಾಂತರವನ್ನು ತಡೆಯುತ್ತದೆ. ಲೆಗಸಿ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆ ಅಗತ್ಯವಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಈ ವಿಧಾನವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಗುಣಲಕ್ಷಣಗಳು ತಮ್ಮ ಸ್ಥಳೀಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಉಳಿಸಿಕೊಳ್ಳುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಸೇವಿಸುವ ಸಿಸ್ಟಮ್‌ನ ಆಂತರಿಕಗಳೊಂದಿಗೆ ಘರ್ಷಣೆಯನ್ನು ತಡೆಯುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ, ಬಳಕೆ ರೋಲ್ಅಪ್-ಪ್ಲಗಿನ್-ಕಾಪಿ ಪರಿಹಾರದ ಮತ್ತೊಂದು ಅಮೂಲ್ಯ ಭಾಗವಾಗಿದೆ. ಈ ಪ್ಲಗಿನ್ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಅಗತ್ಯವಾದ ಸ್ಥಿರ ಸ್ವತ್ತುಗಳು ಅಥವಾ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ನಕಲು ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು ಸಂಕೀರ್ಣ ಪರಿಸರದಲ್ಲಿ ನಿಯೋಜನೆಗೆ ಅವಶ್ಯಕವಾಗಿದೆ. ನಿರ್ದಿಷ್ಟ ಫೈಲ್‌ಗಳನ್ನು ಸರಿಸಲು ಅಥವಾ ಅಗತ್ಯವಿರುವಂತೆ ಮರುಹೆಸರಿಸಲು ಅನುಮತಿಸುವ ಮೂಲಕ ಇದು ಬಿಲ್ಡ್ ಸಿಸ್ಟಮ್‌ಗೆ ನಮ್ಯತೆಯನ್ನು ಸೇರಿಸುತ್ತದೆ. ಸಂಯೋಜಿಸಿದಾಗ, ಈ ಆಜ್ಞೆಗಳು ಮತ್ತು ಪ್ಲಗ್‌ಇನ್‌ಗಳು ವೈಟ್‌ನ ವೇಗದ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಳಸುವ ಪ್ರಯೋಜನಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಫೌಂಡ್ರಿವಿಟಿಟಿಯಂತಹ ಸಿಸ್ಟಮ್‌ಗಳೊಂದಿಗೆ ಔಟ್‌ಪುಟ್ ಹೊಂದಿಕೆಯಾಗುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

import { defineConfig } from 'vite';
import copy from 'rollup-plugin-copy';
import { svelte } from '@sveltejs/vite-plugin-svelte';
import path from 'path';

export default defineConfig({
  resolve: {
    alias: {
      // Define your custom aliases here
    },
  },
  build: {
    outDir: 'dist',
    emptyOutDir: true,
    minify: false,
    lib: {
      name: 'animabf',
      entry: 'src/animabf.mjs',
      formats: ['es'],
    },
    rollupOptions: {
      output: {
        preserveModules: true,
        preserveModulesRoot: 'src',
        entryFileNames: ({ name: fileName }) => {
          return `${fileName}.js`;
        },
        assetFileNames: 'animabf.[ext]'
      }
    }
  },
  plugins: [
    svelte(),
    copy({ /* Specify your file copying rules */ })
  ]
});

// Install Babel and necessary presets/plugins
// npm install --save-dev @babel/core @babel/preset-env

module.exports = {
  presets: [
    ['@babel/preset-env', {
      targets: { esmodules: true }, // Adjust for desired compatibility
      useBuiltIns: 'usage',
      corejs: 3
    }]
  ],
  plugins: [
    '@babel/plugin-syntax-class-properties'
  ]
};

{
  "compilerOptions": {
    "target": "ESNext",
    "useDefineForClassFields": false,
    "lib": ["dom", "dom.iterable", "esnext"],
    "moduleResolution": "node",
    "esModuleInterop": true,
    "allowJs": true,
    "checkJs": true,
    "strict": true,
    "strictNullChecks": true,
  }
}

ವೈಟ್‌ನಲ್ಲಿ ವರ್ಗ ಕ್ಷೇತ್ರ ರೂಪಾಂತರಗಳನ್ನು ತಿಳಿಸುವುದು: ಒಳನೋಟಗಳು ಮತ್ತು ಪರ್ಯಾಯಗಳು

Vite ಮತ್ತು ವರ್ಗ ಕ್ಷೇತ್ರ ರೂಪಾಂತರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಅನ್ವೇಷಿಸಲು ಒಂದು ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಈ ರೂಪಾಂತರಗಳು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಏಕೆ ಸಂಭವಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು. Vite ಹುಡ್ ಅಡಿಯಲ್ಲಿ ರೋಲಪ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ರೋಲಪ್, ಉತ್ತಮ ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವರ್ಗ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಬಹುದು. ಆದಾಗ್ಯೂ, FoundryVTT ವಿಸ್ತರಣೆಗಳಂತಹ ಯೋಜನೆಗಳಿಗೆ, ಈ ಆಪ್ಟಿಮೈಸೇಶನ್ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು ಏಕೆಂದರೆ FoundryVTT ವರ್ಗ ಕ್ಷೇತ್ರಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮತ್ತು ನಿರ್ವಹಿಸುವ ನಿರ್ದಿಷ್ಟ ಮಾರ್ಗವನ್ನು ಅವಲಂಬಿಸಿದೆ. ಈ ಕ್ಷೇತ್ರಗಳನ್ನು ಪರಿವರ್ತಿಸುವ ಮೂಲಕ, Vite ಅಜಾಗರೂಕತೆಯಿಂದ ಹೊಂದಾಣಿಕೆಯನ್ನು ಮುರಿಯುತ್ತದೆ, ಇದು ಪ್ಲಗಿನ್ ಅಥವಾ ವಿಸ್ತರಣೆಯನ್ನು ಸೇವಿಸುವ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಈ ಸಮಸ್ಯೆಗಳನ್ನು ತಗ್ಗಿಸಲು, ನಿಮ್ಮ ಬಿಲ್ಡ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಸರಿಹೊಂದಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ಸೆಟ್ಟಿಂಗ್ DefineForClassFields ಅನ್ನು ಬಳಸಿ ನಿಮ್ಮಲ್ಲಿ jsconfig.json ತಪ್ಪಾಗಿ ಕಂಪೈಲರ್ ಅನ್ನು ಬಳಸದಂತೆ ತಡೆಯಬಹುದು Object.defineProperty ವರ್ಗ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ, ಹೀಗೆ ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಹಾಗೆಯೇ ಇರಿಸುತ್ತದೆ. ಸ್ಥಳೀಯ ವರ್ಗದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನಿರೀಕ್ಷಿಸುವ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಗ್ರಂಥಾಲಯಗಳು ಅಥವಾ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಇದಲ್ಲದೆ, ಫೈನ್-ಟ್ಯೂನಿಂಗ್ ರೋಲಪ್‌ನಂತಹ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ preserveModules ಮತ್ತು ಫೈಲ್ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವುದರಿಂದ ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ಗಳು ಫೌಂಡ್ರಿವಿಟಿಟಿಯಂತಹ ಬಾಹ್ಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಸರಿಯಾಗಿ ಬಳಸಬಹುದಾದ ರೀತಿಯಲ್ಲಿ ರಚನೆಯಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಪರಿಗಣಿಸಬೇಕಾದ ಮತ್ತೊಂದು ಪರ್ಯಾಯವೆಂದರೆ ಬಾಬೆಲ್ ಅನ್ನು ಬಳಸುವುದು. ನಿಮ್ಮ Vite ಕಾನ್ಫಿಗರೇಶನ್‌ನೊಂದಿಗೆ Babel ಅನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ನೀವು ನಿರ್ದಿಷ್ಟ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಹತೋಟಿಗೆ ತರಬಹುದು @babel/plugin-syntax-class-properties ವರ್ಗ ಕ್ಷೇತ್ರಗಳ ರೂಪಾಂತರವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತಡೆಯಲು. ವಿವಿಧ ಹಂತದ ES ಮಾಡ್ಯೂಲ್ ಬೆಂಬಲದೊಂದಿಗೆ ಬಹು ಪರಿಸರವನ್ನು ಗುರಿಯಾಗಿಸುವಾಗ ಈ ವಿಧಾನವು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ನಿಮ್ಮ ಪ್ಲಗ್‌ಇನ್ ವಿಭಿನ್ನ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ ಸ್ಥಿರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.