mirror of
https://github.com/vrtmrz/obsidian-livesync.git
synced 2026-06-13 18:00:14 +00:00
vorotamoroz
364 lines
14 KiB
JavaScript
364 lines
14 KiB
JavaScript
import * as acorn from 'acorn';
|
|
import fs from 'fs';
|
|
|
|
// Parse command line arguments
|
|
const args = process.argv.slice(2);
|
|
let file = 'main.js';
|
|
let target = 2018;
|
|
let ios = null;
|
|
|
|
// Help menu
|
|
if (args.includes('--help') || args.includes('-h')) {
|
|
console.log(`Usage: node utils/check-compatibility.js [options]
|
|
Options:
|
|
--file <path> Path to the bundle file to check (default: main.js)
|
|
--target <year> Target ECMAScript version (default: 2018)
|
|
--ios <version> Target iOS version (e.g. 14, 15, 16.4). Sets defaults automatically.
|
|
--[no-]allow-dynamic-import Allow dynamic import() expressions
|
|
--[no-]allow-bigint Allow BigInt literals
|
|
--[no-]allow-numeric-separator Allow numeric separators (e.g. 1_000)
|
|
--[no-]allow-class-fields Allow public/private/static class fields
|
|
--[no-]allow-class-static-blocks Allow class static initialization blocks
|
|
--[no-]allow-regexp-lookbehind Allow RegExp lookbehind assertions ((?<=...) / (?<!...))
|
|
--[no-]allow-regexp-indices Allow RegExp 'd' (indices) flag
|
|
--[no-]allow-regexp-v-flag Allow RegExp 'v' (Unicode properties) flag
|
|
`);
|
|
process.exit(0);
|
|
}
|
|
|
|
for (let i = 0; i < args.length; i++) {
|
|
if (args[i] === '--file' && args[i + 1]) {
|
|
file = args[i + 1];
|
|
i++;
|
|
} else if (args[i] === '--target' && args[i + 1]) {
|
|
target = parseInt(args[i + 1], 10);
|
|
i++;
|
|
} else if (args[i] === '--ios' && args[i + 1]) {
|
|
ios = parseFloat(args[i + 1]);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
// Default feature flags based on target ECMA version
|
|
let allowDynamicImport = target >= 2020;
|
|
let allowBigInt = target >= 2020;
|
|
let allowNumericSeparator = target >= 2021;
|
|
let allowClassFields = target >= 2022;
|
|
let allowClassStaticBlocks = target >= 2022;
|
|
let allowRegexpLookbehind = target >= 2023;
|
|
let allowRegexpIndices = target >= 2022;
|
|
let allowRegexpVFlag = target >= 2024;
|
|
|
|
// Override feature flags if target iOS version is specified
|
|
if (ios !== null) {
|
|
// Determine a general baseline ECMA version for parser reports
|
|
if (ios >= 16.4) target = 2022;
|
|
else if (ios >= 15.0) target = 2021;
|
|
else if (ios >= 14.0) target = 2020;
|
|
else target = 2018;
|
|
|
|
allowDynamicImport = ios >= 11.3;
|
|
allowBigInt = ios >= 14.0;
|
|
allowNumericSeparator = ios >= 14.0;
|
|
allowClassFields = ios >= 14.5;
|
|
allowRegexpIndices = ios >= 15.0;
|
|
allowClassStaticBlocks = ios >= 16.4;
|
|
allowRegexpLookbehind = ios >= 16.4;
|
|
allowRegexpVFlag = ios >= 17.0;
|
|
}
|
|
|
|
// Override defaults with explicit command line options if specified
|
|
for (let i = 0; i < args.length; i++) {
|
|
if (args[i] === '--allow-dynamic-import') allowDynamicImport = true;
|
|
else if (args[i] === '--no-allow-dynamic-import') allowDynamicImport = false;
|
|
else if (args[i] === '--allow-bigint') allowBigInt = true;
|
|
else if (args[i] === '--no-allow-bigint') allowBigInt = false;
|
|
else if (args[i] === '--allow-numeric-separator') allowNumericSeparator = true;
|
|
else if (args[i] === '--no-allow-numeric-separator') allowNumericSeparator = false;
|
|
else if (args[i] === '--allow-class-fields') allowClassFields = true;
|
|
else if (args[i] === '--no-allow-class-fields') allowClassFields = false;
|
|
else if (args[i] === '--allow-class-static-blocks') allowClassStaticBlocks = true;
|
|
else if (args[i] === '--no-allow-class-static-blocks') allowClassStaticBlocks = false;
|
|
else if (args[i] === '--allow-regexp-lookbehind') allowRegexpLookbehind = true;
|
|
else if (args[i] === '--no-allow-regexp-lookbehind') allowRegexpLookbehind = false;
|
|
else if (args[i] === '--allow-regexp-indices') allowRegexpIndices = true;
|
|
else if (args[i] === '--no-allow-regexp-indices') allowRegexpIndices = false;
|
|
else if (args[i] === '--allow-regexp-v-flag') allowRegexpVFlag = true;
|
|
else if (args[i] === '--no-allow-regexp-v-flag') allowRegexpVFlag = false;
|
|
}
|
|
|
|
if (!fs.existsSync(file)) {
|
|
console.error(`Error: File '${file}' does not exist.`);
|
|
process.exit(1);
|
|
}
|
|
|
|
const code = fs.readFileSync(file, 'utf8');
|
|
let ast;
|
|
|
|
const targetInfo = ios !== null ? `iOS ${ios}` : `ES${target}`;
|
|
console.log(`Parsing '${file}' to inspect compatibility (target ${targetInfo})...`);
|
|
console.log(`Rules:
|
|
Dynamic Import: ${allowDynamicImport ? 'Allowed' : 'Prohibited'}
|
|
BigInt: ${allowBigInt ? 'Allowed' : 'Prohibited'}
|
|
Numeric Separators: ${allowNumericSeparator ? 'Allowed' : 'Prohibited'}
|
|
Class Fields: ${allowClassFields ? 'Allowed' : 'Prohibited'}
|
|
Class Static Block: ${allowClassStaticBlocks ? 'Allowed' : 'Prohibited'}
|
|
RegExp Lookbehind: ${allowRegexpLookbehind ? 'Allowed' : 'Prohibited'}
|
|
RegExp Indices (d): ${allowRegexpIndices ? 'Allowed' : 'Prohibited'}
|
|
RegExp Unicode (v): ${allowRegexpVFlag ? 'Allowed' : 'Prohibited'}
|
|
`);
|
|
|
|
try {
|
|
ast = acorn.parse(code, { ecmaVersion: 'latest', sourceType: 'script' });
|
|
} catch (err) {
|
|
console.error(`Syntax Error: Failed to parse '${file}' due to a syntax issue:`);
|
|
console.error(err.message);
|
|
if (err.pos !== undefined) {
|
|
const line = code.substring(0, err.pos).split('\n').length;
|
|
console.error(`Location: line ${line}, character ${err.pos}`);
|
|
const start = Math.max(0, err.pos - 50);
|
|
const end = Math.min(code.length, err.pos + 50);
|
|
console.error('Context around error:');
|
|
console.error(code.substring(start, end));
|
|
console.error(' '.repeat(err.pos - start) + '^');
|
|
}
|
|
process.exit(1);
|
|
}
|
|
|
|
// Violations list
|
|
const violations = [];
|
|
|
|
function hasLookbehind(pattern) {
|
|
let index = 0;
|
|
while (true) {
|
|
const match = pattern.indexOf('(?<=', index);
|
|
const match2 = pattern.indexOf('(?<!', index);
|
|
const pos = (match !== -1 && match2 !== -1) ? Math.min(match, match2) : (match !== -1 ? match : match2);
|
|
if (pos === -1) break;
|
|
|
|
let backslashes = 0;
|
|
for (let i = pos - 1; i >= 0; i--) {
|
|
if (pattern[i] === '\\') backslashes++;
|
|
else break;
|
|
}
|
|
if (backslashes % 2 === 0) {
|
|
return true;
|
|
}
|
|
index = pos + 4;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function checkNode(node) {
|
|
if (!node || typeof node !== 'object') return;
|
|
|
|
if (node.type) {
|
|
// 1. Optional catch binding (ES2019 / iOS 11.3+)
|
|
if (node.type === 'CatchClause' && !node.param) {
|
|
if (target < 2019 && ios === null) {
|
|
violations.push({
|
|
feature: 'Optional catch binding (ES2019 / iOS 11.3+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
} else if (ios !== null && ios < 11.3) {
|
|
violations.push({
|
|
feature: 'Optional catch binding (iOS 11.3+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 2. Dynamic import (ES2020 / iOS 11.3+)
|
|
if (node.type === 'ImportExpression') {
|
|
if (!allowDynamicImport) {
|
|
violations.push({
|
|
feature: 'Dynamic import (ES2020 / iOS 11.3+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 3. import.meta (ES2020 / iOS 11.3+)
|
|
if (node.type === 'MetaProperty' && node.meta && node.meta.name === 'import') {
|
|
if (!allowDynamicImport) {
|
|
violations.push({
|
|
feature: 'import.meta (ES2020 / iOS 11.3+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 4. Optional chaining (ES2020 / iOS 13.4+)
|
|
if (node.type === 'ChainExpression') {
|
|
const isProhibited = ios !== null ? ios < 13.4 : target < 2020;
|
|
if (isProhibited) {
|
|
violations.push({
|
|
feature: 'Optional chaining (ES2020 / iOS 13.4+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 5. Nullish coalescing (ES2020 / iOS 13.4+)
|
|
if (node.type === 'LogicalExpression' && node.operator === '??') {
|
|
const isProhibited = ios !== null ? ios < 13.4 : target < 2020;
|
|
if (isProhibited) {
|
|
violations.push({
|
|
feature: 'Nullish coalescing (ES2020 / iOS 13.4+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 6. BigInt literal (ES2020 / iOS 14.0+)
|
|
if (node.type === 'Literal' && node.bigint !== undefined) {
|
|
if (!allowBigInt) {
|
|
violations.push({
|
|
feature: 'BigInt literal (ES2020 / iOS 14.0+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 7. Logical assignment (ES2021 / iOS 14.0+)
|
|
if (node.type === 'AssignmentExpression' && ['||=', '&&=', '??='].includes(node.operator)) {
|
|
const isProhibited = ios !== null ? ios < 14.0 : target < 2021;
|
|
if (isProhibited) {
|
|
violations.push({
|
|
feature: `Logical assignment operator '${node.operator}' (ES2021 / iOS 14.0+)`,
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 8. Numeric separators (ES2021 / iOS 14.0+)
|
|
if (node.type === 'Literal' && typeof node.value === 'number' && node.raw && node.raw.includes('_')) {
|
|
if (!allowNumericSeparator) {
|
|
violations.push({
|
|
feature: 'Numeric separator (ES2021 / iOS 14.0+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 9. Class Fields (ES2022 / iOS 14.0+ public, iOS 14.5+ private/static)
|
|
if (node.type === 'PropertyDefinition') {
|
|
if (!allowClassFields) {
|
|
const requiredVersion = node.key.type === 'PrivateIdentifier' || node.static ? 'iOS 14.5+' : 'iOS 14.0+';
|
|
violations.push({
|
|
feature: `Class field definition '${node.key.name || node.key.value || '#private'}' (ES2022 / ${requiredVersion})`,
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 10. Class Static Initialization Blocks (ES2022 / iOS 16.4+)
|
|
if (node.type === 'StaticBlock') {
|
|
if (!allowClassStaticBlocks) {
|
|
violations.push({
|
|
feature: 'Class static initialization block (ES2022 / iOS 16.4+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
// 11. RegExp lookbehind assertions (ES2018 / iOS 16.4+)
|
|
if (node.type === 'Literal' && node.regex) {
|
|
if (!allowRegexpLookbehind && hasLookbehind(node.regex.pattern)) {
|
|
violations.push({
|
|
feature: 'RegExp Lookbehind assertion (iOS 16.4+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
if (!allowRegexpIndices && node.regex.flags.includes('d')) {
|
|
violations.push({
|
|
feature: "RegExp 'd' (indices) flag (ES2022 / iOS 15.0+)",
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
if (!allowRegexpVFlag && node.regex.flags.includes('v')) {
|
|
violations.push({
|
|
feature: "RegExp 'v' (Unicode properties) flag (ES2024 / iOS 17.0+)",
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
|
|
if ((node.type === 'NewExpression' || node.type === 'CallExpression') && node.callee && node.callee.name === 'RegExp') {
|
|
if (!allowRegexpLookbehind && node.arguments[0] && node.arguments[0].type === 'Literal' && typeof node.arguments[0].value === 'string') {
|
|
if (hasLookbehind(node.arguments[0].value)) {
|
|
violations.push({
|
|
feature: 'RegExp Lookbehind assertion (iOS 16.4+)',
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
if (node.arguments[1] && node.arguments[1].type === 'Literal' && typeof node.arguments[1].value === 'string') {
|
|
const flags = node.arguments[1].value;
|
|
if (!allowRegexpIndices && flags.includes('d')) {
|
|
violations.push({
|
|
feature: "RegExp 'd' (indices) flag (ES2022 / iOS 15.0+)",
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
if (!allowRegexpVFlag && flags.includes('v')) {
|
|
violations.push({
|
|
feature: "RegExp 'v' (Unicode properties) flag (ES2024 / iOS 17.0+)",
|
|
pos: node.start,
|
|
node
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const key in node) {
|
|
if (key === 'loc' || key === 'start' || key === 'end') continue;
|
|
const val = node[key];
|
|
if (Array.isArray(val)) {
|
|
for (const child of val) {
|
|
checkNode(child);
|
|
}
|
|
} else if (val && typeof val === 'object') {
|
|
checkNode(val);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Run compatibility checks on the AST
|
|
checkNode(ast);
|
|
|
|
if (violations.length > 0) {
|
|
console.error(`\nCompatibility Check Failed: Found ${violations.length} prohibited features.`);
|
|
violations.forEach((v, index) => {
|
|
const line = code.substring(0, v.pos).split('\n').length;
|
|
console.error(`\n[${index + 1}] Prohibited feature: ${v.feature}`);
|
|
console.error(`Location: line ${line}, character ${v.pos}`);
|
|
const start = Math.max(0, v.pos - 50);
|
|
const end = Math.min(code.length, v.pos + 50);
|
|
console.error('Context around feature:');
|
|
console.error(code.substring(start, end));
|
|
console.error(' '.repeat(v.pos - start) + '^');
|
|
});
|
|
process.exit(1);
|
|
}
|
|
|
|
console.log(`\nCompatibility Check Passed: '${file}' matches the compatibility rules.`);
|
|
process.exit(0);
|