clone-alert 0.3.0

package/dist/svelte.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeSvelte = tokenizeSvelte;
+/**
+ * `.svelte` tokenizer: `<script>`/`<script module>` + markup (ast.fragment).
+ * Built on top of the shared layer in tokenizers.ts (optional/moduleResolveDirs/
+ * remap/tokenizeTypeScript) and the sentinel `S` from core.ts. The core knows
+ * nothing about Svelte.
+ *
+ * Two token layers:
+ *   1. markup structure (tags, blocks, directives, static text) -> images with
+ *      the SV prefix (via the sentinel S), so they do NOT match script tokens;
+ *   2. expressions inside `{...}`/bindings -> the same TypeScript in the same
+ *      component scope, so we slice the source and run it through the shared
+ *      tokenizeTypeScript WITHOUT a prefix, so a duplicated expression across
+ *      template<->script is caught.
+ *
+ * @packageDocumentation
+ */
+const ts = __importStar(require("typescript"));
+const core_1 = require("./core");
+const tokenizers_1 = require("./tokenizers");
+const SV = `${core_1.S}SV:`; // structural markup marker
+const SV_TEXT = `${core_1.S}SVTEXT`; // non-empty static text
+let warnedSvelte = false;
+/** Build an offset -> {line, col} mapper (both 1-based) from a precomputed line-start table. */
+function makeOffsetMapper(source) {
+    const lineStarts = [0];
+    for (let i = 0; i < source.length; i++) {
+        if (source.charCodeAt(i) === 10 /* \n */)
+            lineStarts.push(i + 1);
+    }
+    return (offset) => {
+        let lo = 0;
+        let hi = lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStarts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return { line: lo + 1, col: offset - lineStarts[lo] + 1 };
+    };
+}
+/** Tokenize a `.svelte` component (`<script>` blocks + markup). */
+function tokenizeSvelte(filePath, source, options = {}) {
+    const svelte = (0, tokenizers_1.optional)('svelte/compiler', (0, tokenizers_1.moduleResolveDirs)(filePath));
+    if (!svelte || typeof svelte.parse !== 'function') {
+        if (!warnedSvelte) {
+            console.warn('[cpd] .svelte skipped: install svelte');
+            warnedSvelte = true;
+        }
+        return [];
+    }
+    let ast;
+    try {
+        // modern: true -> markup lives in ast.fragment (becomes the default in Svelte 6).
+        ast = svelte.parse(source, { filename: filePath, modern: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    const at = makeOffsetMapper(source);
+    // --- Structural markup token (coordinates from the node offset) ---
+    const emitStruct = (image, node) => {
+        const off = typeof node?.start === 'number' ? node.start : 0;
+        const { line, col } = at(off);
+        out.push({ image, line, column: col });
+    };
+    // --- Expression: slice the source -> shared TS tokenizer -> remap ---
+    const emitExpr = (node) => {
+        if (!node || typeof node.start !== 'number' || typeof node.end !== 'number')
+            return;
+        const code = source.slice(node.start, node.end);
+        if (!code)
+            return;
+        const { line, col } = at(node.start);
+        for (const t of (0, tokenizers_1.tokenizeTypeScript)(filePath, code, options, ts.ScriptKind.TS)) {
+            out.push((0, tokenizers_1.remap)(t, line, col));
+        }
+    };
+    // --- <script> and <script module>: plain TS, like a regular .ts ---
+    for (const part of [ast.instance, ast.module]) {
+        if (!part?.content)
+            continue;
+        const start = part.content.start;
+        const end = part.content.end;
+        const { line, col } = at(start);
+        for (const t of (0, tokenizers_1.tokenizeTypeScript)(filePath, source.slice(start, end), options, ts.ScriptKind.TS)) {
+            out.push((0, tokenizers_1.remap)(t, line, col));
+        }
+        out.push({ image: '', line, column: col, barrier: true });
+    }
+    // --- Markup ---
+    const walkAttr = (attr) => {
+        if (!attr || typeof attr !== 'object')
+            return;
+        switch (attr.type) {
+            case 'Attribute': {
+                emitStruct(`${SV}@${attr.name}`, attr);
+                const v = attr.value;
+                if (v === true)
+                    return; // boolean attribute with no value
+                if (Array.isArray(v))
+                    v.forEach(walkNode); // (Text | ExpressionTag)[]
+                else
+                    walkNode(v); // a single ExpressionTag
+                return;
+            }
+            case 'SpreadAttribute':
+                emitStruct(`${SV}{...}`, attr);
+                emitExpr(attr.expression);
+                return;
+            case 'BindDirective':
+                emitStruct(`${SV}bind:${attr.name}`, attr);
+                emitExpr(attr.expression);
+                return;
+            case 'OnDirective':
+                emitStruct(`${SV}on:${attr.name}`, attr);
+                emitExpr(attr.expression);
+                return;
+            case 'ClassDirective':
+                emitStruct(`${SV}class:${attr.name}`, attr);
+                emitExpr(attr.expression);
+                return;
+            case 'StyleDirective': {
+                emitStruct(`${SV}style:${attr.name}`, attr);
+                const v = attr.value;
+                if (v === true)
+                    return;
+                if (Array.isArray(v))
+                    v.forEach(walkNode);
+                else
+                    walkNode(v);
+                return;
+            }
+            case 'UseDirective':
+                emitStruct(`${SV}use:${attr.name}`, attr);
+                emitExpr(attr.expression);
+                return;
+            case 'TransitionDirective': {
+                const kw = attr.intro && attr.outro ? 'transition' : attr.outro ? 'out' : 'in';
+                emitStruct(`${SV}${kw}:${attr.name}`, attr);
+                emitExpr(attr.expression);
+                return;
+            }
+            case 'AnimateDirective':
+                emitStruct(`${SV}animate:${attr.name}`, attr);
+                emitExpr(attr.expression);
+                return;
+            case 'LetDirective':
+                emitStruct(`${SV}let:${attr.name}`, attr);
+                return;
+            case 'AttachTag':
+                emitStruct(`${SV}@attach`, attr);
+                emitExpr(attr.expression);
+                return;
+            default:
+                if (attr.expression)
+                    emitExpr(attr.expression);
+                return;
+        }
+    };
+    function walkNode(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        switch (node.type) {
+            case 'Fragment':
+                (node.nodes ?? []).forEach(walkNode);
+                return;
+            case 'Text':
+                if (typeof node.data === 'string' && node.data.trim())
+                    emitStruct(SV_TEXT, node);
+                return;
+            case 'Comment':
+                return;
+            case 'ExpressionTag':
+            case 'HtmlTag':
+            case 'RenderTag':
+            case 'AttachTag':
+                emitExpr(node.expression);
+                return;
+            case 'ConstTag':
+                emitStruct(`${SV}@const`, node);
+                emitExpr(node.declaration);
+                return;
+            case 'DebugTag':
+                (node.identifiers ?? []).forEach(emitExpr);
+                return;
+            case 'IfBlock':
+                emitStruct(`${SV}#if`, node);
+                emitExpr(node.test);
+                walkNode(node.consequent);
+                if (node.alternate)
+                    walkNode(node.alternate);
+                return;
+            case 'EachBlock':
+                emitStruct(`${SV}#each`, node);
+                emitExpr(node.expression);
+                if (node.key)
+                    emitExpr(node.key);
+                walkNode(node.body);
+                if (node.fallback)
+                    walkNode(node.fallback);
+                return;
+            case 'AwaitBlock':
+                emitStruct(`${SV}#await`, node);
+                emitExpr(node.expression);
+                if (node.pending)
+                    walkNode(node.pending);
+                if (node.then)
+                    walkNode(node.then);
+                if (node.catch)
+                    walkNode(node.catch);
+                return;
+            case 'KeyBlock':
+                emitStruct(`${SV}#key`, node);
+                emitExpr(node.expression);
+                walkNode(node.fragment);
+                return;
+            case 'SnippetBlock':
+                emitStruct(`${SV}#snippet`, node);
+                walkNode(node.body);
+                return;
+            default: {
+                // Element-like: RegularElement / Component / SvelteElement /
+                // SvelteComponent / SvelteSelf / SvelteFragment / SlotElement /
+                // TitleElement / SvelteWindow|Body|Head|Document|Boundary.
+                if (Array.isArray(node.attributes) || node.fragment) {
+                    emitStruct(`${SV}<${node.name ?? node.type}`, node);
+                    (node.attributes ?? []).forEach(walkAttr);
+                    if (node.fragment)
+                        walkNode(node.fragment);
+                    return;
+                }
+                // Unknown node — try the common fields so we don't lose expressions.
+                if (node.expression)
+                    emitExpr(node.expression);
+                if (node.fragment)
+                    walkNode(node.fragment);
+                if (Array.isArray(node.nodes))
+                    node.nodes.forEach(walkNode);
+                return;
+            }
+        }
+    }
+    // Markup is tokenized only when the toggle is on (default yes). Markup and
+    // script are usually run at different --minimum-tokens thresholds.
+    if ((options.svelteTemplates ?? true) && ast.fragment)
+        walkNode(ast.fragment);
+    return out;
+}

package/dist/tokenizers.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The TypeScript/JavaScript tokenizer plus the shared helpers used by every
+ * framework tokenizer extension (`optional`, `moduleResolveDirs`, `remap`).
+ *
+ * @packageDocumentation
+ */
+import * as ts from 'typescript';
+import { type RawToken } from './core';
+export interface TokenizeOptions {
+    ignoreIdentifiers?: boolean;
+    ignoreLiterals?: boolean;
+    /** Split TS-file tokens to match PMD typescript (templates, regexp). `.ts/.tsx` only. */
+    pmdTypescriptCompatibility?: boolean;
+    /**
+     * Tokenize `.svelte` markup (ast.fragment), not just `<script>`. Markup and
+     * script usually want different `--minimum-tokens` thresholds, so this is put
+     * behind a toggle: turn it off to scan scripts on their own.
+     */
+    svelteTemplates?: boolean;
+    /**
+     * Tokenize `.vue` markup (descriptor.template.ast), not just `<script>`. Like
+     * svelteTemplates, this layer sits behind a toggle so markup and code can run
+     * at separate `--minimum-tokens` thresholds.
+     */
+    vueTemplates?: boolean;
+}
+export declare const DEFAULTS: Required<TokenizeOptions>;
+/**
+ * Load an optional compiler (`@angular/compiler`, `@vue/compiler-sfc`, `svelte`)
+ * — a peerDependency. Resolution starts FROM the analyzed file and walks up the
+ * tree (so we use the compiler version installed in the scanned project), and
+ * only then falls back to clone-alert's own node_modules. `fromPaths` is usually
+ * `[dirname(filePath)]`; Node climbs node_modules from there.
+ */
+export declare function optional<T = any>(name: string, fromPaths?: string[]): T | null;
+/**
+ * Starting point for resolving a peer compiler: the directory of the analyzed
+ * file. Node walks up node_modules from there to the project root.
+ */
+export declare function moduleResolveDirs(filePath: string): string[];
+/**
+ * Remap an embedded block's positions into file coordinates. Block tokens are
+ * counted from (0,0) within the block; baseLine/baseCol (1-based) give the
+ * absolute start of the block. The column shift applies only to the block's
+ * first line.
+ */
+export declare function remap(tok: RawToken, baseLine: number, baseCol: number): RawToken;
+/**
+ * Tokenize TS / TSX / JSX via the TypeScript scanner. CPD counts the stream of
+ * lexical tokens, including keywords and punctuation.
+ */
+export declare function tokenizeTypeScript(filePath: string, source: string, opts?: TokenizeOptions, scriptKind?: ts.ScriptKind): RawToken[];
+export declare function scriptKindFor(ext: string): ts.ScriptKind;