@reforma/project-tokens 0.0.1

package/dist/mutation/documents.js

@@ -0,0 +1,77 @@
+import { applyEdits, modify } from 'jsonc-parser';
+import { createHash } from 'node:crypto';
+import { relative, resolve, sep } from 'node:path';
+import { readTokenDependency } from '../generation.js';
+import { TokenMutationError } from './types.js';
+export class TokenMutationDocuments {
+    workspaceRoot;
+    entryFile;
+    current;
+    original;
+    constructor(workspaceRoot, entryFile, current) {
+        this.workspaceRoot = workspaceRoot;
+        this.entryFile = entryFile;
+        this.current = current;
+        this.original = { ...current };
+    }
+    static async load(options, compilation) {
+        const documents = Object.create(null);
+        for (const dependency of compilation.dependencies) {
+            const text = await readTokenDependency(options.workspaceRoot, dependency.path);
+            const hash = text === null ? null : createHash('sha256').update(text).digest('hex');
+            if (text === null || hash !== dependency.hash) {
+                throw new TokenMutationError('REVISION_CONFLICT', 'Token sources changed while preparing the edit.');
+            }
+            documents[dependency.path] = text;
+        }
+        const workspaceRoot = resolve(options.workspaceRoot);
+        const entryPath = resolve(workspaceRoot, options.entry ?? '.reforma/tokens/tokens.resolver.json');
+        const entryFile = relative(workspaceRoot, entryPath).split(sep).join('/');
+        return new TokenMutationDocuments(workspaceRoot, entryFile, documents);
+    }
+    get values() {
+        return this.current;
+    }
+    get files() {
+        return Object.keys(this.current);
+    }
+    has(file) {
+        return Object.hasOwn(this.current, file);
+    }
+    parse(file) {
+        return JSON.parse(this.current[file]);
+    }
+    read(file, path) {
+        return path.reduce((value, key) => (value && Object.hasOwn(value, key) ? value[key] : undefined), this.parse(file));
+    }
+    create(file, text = '{}\n') {
+        this.current[file] = text;
+    }
+    edit(file, path, value) {
+        const text = this.current[file];
+        const indent = text.match(/\n([\t ]+)"/)?.[1] ?? '  ';
+        const edits = modify(text, path, value, {
+            formattingOptions: {
+                insertSpaces: !indent.includes('\t'),
+                tabSize: indent.length,
+                eol: text.includes('\r\n') ? '\r\n' : '\n',
+            },
+        });
+        this.current[file] = applyEdits(text, edits);
+    }
+    async assertAvailable(file) {
+        if (this.has(file)
+            || await readTokenDependency(this.workspaceRoot, file) !== null) {
+            throw new TokenMutationError('PATH_EXISTS', `A document already exists at ${file}.`);
+        }
+    }
+    changes() {
+        return Object.entries(this.current)
+            .filter(([file, text]) => this.original[file] !== text)
+            .map(([path, after]) => ({
+            path,
+            before: this.original[path] ?? null,
+            after,
+        }));
+    }
+}

package/dist/mutation/layout.d.ts

@@ -0,0 +1,17 @@
+import { TokenMutationDocuments } from './documents.js';
+import type { TokenEditingProfile } from '../authoring.js';
+export type SupportedEditingProfile = Extract<TokenEditingProfile, {
+    supported: true;
+}>;
+export declare class TokenMutationLayout {
+    readonly documents: TokenMutationDocuments;
+    readonly profile: SupportedEditingProfile;
+    readonly mode: any;
+    readonly modeFiles: Map<string, string>;
+    readonly modePath: Array<string | number>;
+    constructor(documents: TokenMutationDocuments, profile: SupportedEditingProfile);
+    assertModeExists(name: string, message?: string): void;
+    ensureModeFile(name: string): Promise<string>;
+    throwAmbiguous(): never;
+}
+//# sourceMappingURL=layout.d.ts.map

package/dist/mutation/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../src/mutation/layout.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC,mBAAmB,EAAE;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC;AAExF,qBAAa,mBAAmB;IAMxB,QAAQ,CAAC,SAAS,EAAE,sBAAsB;IAC1C,QAAQ,CAAC,OAAO,EAAE,uBAAuB;IAN7C,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IACnB,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IAE1C,YACa,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,uBAAuB,EAc5C;IAED,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,SAAyB,QAI9D;IAEK,cAAc,CAAC,IAAI,EAAE,MAAM,mBAqBhC;IAED,cAAc,IAAI,KAAK,CAKtB;CACJ"}

package/dist/mutation/layout.js

@@ -0,0 +1,43 @@
+import { dirname } from 'node:path';
+import { TokenMutationError } from './types.js';
+export class TokenMutationLayout {
+    documents;
+    profile;
+    mode;
+    modeFiles;
+    modePath;
+    constructor(documents, profile) {
+        this.documents = documents;
+        this.profile = profile;
+        const resolver = documents.parse(documents.entryFile);
+        const modeOrder = resolver.resolutionOrder[1];
+        this.mode = modeOrder.$ref ? resolver.modifiers.mode : modeOrder;
+        this.modePath = modeOrder.$ref
+            ? ['modifiers', 'mode']
+            : ['resolutionOrder', 1];
+        this.modeFiles = new Map(Object.entries(profile.modeFiles).filter((entry) => entry[1] !== null));
+    }
+    assertModeExists(name, message = 'Mode does not exist.') {
+        if (!Object.hasOwn(this.mode.contexts, name)) {
+            throw new TokenMutationError('MODE_NOT_FOUND', message);
+        }
+    }
+    async ensureModeFile(name) {
+        const existing = this.modeFiles.get(name);
+        if (existing) {
+            return existing;
+        }
+        const directory = dirname(this.documents.entryFile);
+        const encodedName = encodeURIComponent(name);
+        const filename = `${encodedName}.tokens.json`;
+        const file = directory === '.' ? filename : `${directory}/${filename}`;
+        await this.documents.assertAvailable(file);
+        this.documents.create(file);
+        this.modeFiles.set(name, file);
+        this.documents.edit(this.documents.entryFile, [...this.modePath, 'contexts', name], [{ $ref: `${encodeURIComponent(encodedName)}.tokens.json` }]);
+        return file;
+    }
+    throwAmbiguous() {
+        throw new TokenMutationError('AMBIGUOUS_SOURCE', 'Structured editing requires one base set followed by one mode modifier, with independent local documents and an empty default context. Edit this layout in JSON.');
+    }
+}

package/dist/mutation/mode-operations.d.ts

@@ -0,0 +1,15 @@
+import { TokenMutationLayout } from './layout.js';
+import type { TokenCompilation } from '../compilation/compiler.js';
+export declare class TokenModeOperations {
+    private readonly layout;
+    private readonly compilation;
+    constructor(layout: TokenMutationLayout, compilation: TokenCompilation);
+    create(name: string): void;
+    rename(name: string, nextName: string): void;
+    reset(name: string): void;
+    delete(name: string): Promise<void>;
+    rebase(nextDefault: string): Promise<void>;
+    private collectDefinitions;
+    private clearTokenNodes;
+}
+//# sourceMappingURL=mode-operations.d.ts.map

package/dist/mutation/mode-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-operations.d.ts","sourceRoot":"","sources":["../../src/mutation/mode-operations.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGlD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,qBAAa,mBAAmB;IAExB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAFhC,YACqB,MAAM,EAAE,mBAAmB,EAC3B,WAAW,EAAE,gBAAgB,EAC9C;IAEJ,MAAM,CAAC,IAAI,EAAE,MAAM,QAelB;IAED,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,QA6BpC;IAED,KAAK,CAAC,IAAI,EAAE,MAAM,QAsBjB;IAEK,MAAM,CAAC,IAAI,EAAE,MAAM,iBAuBxB;IAEK,MAAM,CAAC,WAAW,EAAE,MAAM,iBA8D/B;IAED,OAAO,CAAC,kBAAkB;IA4B1B,OAAO,CAAC,eAAe;CAoB1B"}

package/dist/mutation/mode-operations.js

@@ -0,0 +1,124 @@
+import { dirname, relative, sep } from 'node:path';
+import { encodeJsonPointer } from '../json-pointer.js';
+import { TokenMutationError } from './types.js';
+export class TokenModeOperations {
+    layout;
+    compilation;
+    constructor(layout, compilation) {
+        this.layout = layout;
+        this.compilation = compilation;
+    }
+    create(name) {
+        const { documents, mode, modePath } = this.layout;
+        if (!name || Object.hasOwn(mode.contexts, name)) {
+            throw new TokenMutationError('MODE_EXISTS', 'Choose a new nonempty mode name.');
+        }
+        documents.edit(documents.entryFile, [...modePath, 'contexts', name], []);
+    }
+    rename(name, nextName) {
+        const { documents, mode, modePath } = this.layout;
+        this.layout.assertModeExists(name);
+        if (!nextName || Object.hasOwn(mode.contexts, nextName)) {
+            throw new TokenMutationError('MODE_EXISTS', 'Choose a new nonempty mode name.');
+        }
+        documents.edit(documents.entryFile, [...modePath, 'contexts', nextName], mode.contexts[name]);
+        documents.edit(documents.entryFile, [...modePath, 'contexts', name], undefined);
+        if (mode.default === name) {
+            documents.edit(documents.entryFile, [...modePath, 'default'], nextName);
+        }
+    }
+    reset(name) {
+        const { documents, mode, modeFiles } = this.layout;
+        this.layout.assertModeExists(name);
+        if (name === mode.default) {
+            throw new TokenMutationError('DEFAULT_RESET', 'The base mode cannot be reset.');
+        }
+        const file = modeFiles.get(name);
+        if (!file) {
+            return;
+        }
+        const extensions = documents.read(file, [])?.$extensions;
+        documents.edit(file, [], extensions === undefined ? {} : { $extensions: extensions });
+    }
+    async delete(name) {
+        const { mode } = this.layout;
+        this.layout.assertModeExists(name);
+        if (name === mode.default) {
+            throw new TokenMutationError('DEFAULT_MODE', 'The default mode can be renamed but cannot be deleted.');
+        }
+        if (Object.keys(mode.contexts).length === 1) {
+            throw new TokenMutationError('LAST_MODE', 'At least one mode must remain.');
+        }
+        this.layout.documents.edit(this.layout.documents.entryFile, [...this.layout.modePath, 'contexts', name], undefined);
+    }
+    async rebase(nextDefault) {
+        const { documents, mode, modeFiles, modePath, profile, } = this.layout;
+        this.layout.assertModeExists(nextDefault, 'Replacement mode does not exist.');
+        if (nextDefault === mode.default) {
+            return;
+        }
+        const definitions = this.collectDefinitions();
+        const nextTokens = definitions.get(nextDefault);
+        const previousOverrideFile = modeFiles.get(nextDefault);
+        if (previousOverrideFile) {
+            modeFiles.set(mode.default, previousOverrideFile);
+            const reference = relative(dirname(documents.entryFile), previousOverrideFile).split(sep).map(encodeURIComponent).join('/');
+            documents.edit(documents.entryFile, [...modePath, 'contexts', mode.default], [{ $ref: reference }]);
+        }
+        else {
+            modeFiles.delete(mode.default);
+        }
+        for (const [modeName, tokens] of definitions) {
+            const file = modeName === nextDefault
+                ? profile.baseFile
+                : await this.layout.ensureModeFile(modeName);
+            this.clearTokenNodes(file, documents.parse(file));
+            for (const [path, raw] of tokens) {
+                const inherited = nextTokens.get(path);
+                if (modeName === nextDefault || JSON.stringify(raw) !== JSON.stringify(inherited)) {
+                    documents.edit(file, path.split('.'), raw);
+                }
+            }
+        }
+        documents.edit(documents.entryFile, [...modePath, 'contexts', nextDefault], []);
+        documents.edit(documents.entryFile, [...modePath, 'default'], nextDefault);
+    }
+    collectDefinitions() {
+        const { documents, modeFiles } = this.layout;
+        const sourceFiles = [...modeFiles.values()];
+        const definitions = new Map();
+        for (const permutation of this.compilation.permutations) {
+            const tokens = new Map();
+            for (const token of permutation.tokens) {
+                const path = token.path.split('.');
+                const sourceOwned = token.source.pointer === encodeJsonPointer(path)
+                    && sourceFiles.includes(token.source.file);
+                if (!sourceOwned) {
+                    this.layout.throwAmbiguous();
+                }
+                tokens.set(token.path, {
+                    ...documents.read(token.source.file, path),
+                });
+            }
+            definitions.set(permutation.input.mode, tokens);
+        }
+        return definitions;
+    }
+    clearTokenNodes(file, node, path = []) {
+        if (!node || typeof node !== 'object') {
+            return;
+        }
+        if ('$extends' in node) {
+            this.layout.throwAmbiguous();
+        }
+        if ('$value' in node) {
+            this.layout.documents.edit(file, path, undefined);
+            return;
+        }
+        for (const [key, value] of Object.entries(node)) {
+            if (!key.startsWith('$') || key === '$root') {
+                this.clearTokenNodes(file, value, [...path, key]);
+            }
+        }
+    }
+}

package/dist/mutation/mutations.d.ts

@@ -0,0 +1,11 @@
+import type { TokenCompilationOptions } from '../compilation/compiler.js';
+import type { TokenMutation } from './types.js';
+export { TokenMutationError } from './types.js';
+export type { TokenFileChange, TokenMutation } from './types.js';
+/** Prepare and validate source edits without writing to the workspace. */
+export declare function planTokenMutation(options: Omit<TokenCompilationOptions, 'documents'>, mutation: TokenMutation): Promise<{
+    compilation: import("../compilation/compiler.js").TokenCompilation;
+    changes: import("./types.js").TokenFileChange[];
+    revision: string;
+}>;
+//# sourceMappingURL=mutations.d.ts.map

package/dist/mutation/mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../src/mutation/mutations.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEjE,0EAA0E;AAC1E,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,IAAI,CAAC,uBAAuB,EAAE,WAAW,CAAC,EACnD,QAAQ,EAAE,aAAa;;;;GAqD1B"}

package/dist/mutation/mutations.js

@@ -0,0 +1,41 @@
+import { compileProjectTokens } from '../compilation/compiler.js';
+import { TokenMutationDocuments } from './documents.js';
+import { TokenMutationPlanner } from './planner.js';
+import { TokenMutationError } from './types.js';
+import { validateMutationResult } from './validation.js';
+export { TokenMutationError } from './types.js';
+/** Prepare and validate source edits without writing to the workspace. */
+export async function planTokenMutation(options, mutation) {
+    const current = await compileProjectTokens(options);
+    if (!current.ok) {
+        throw new TokenMutationError('INVALID_SOURCE', 'Fix token diagnostics before structured editing.', current);
+    }
+    if (!current.editing?.supported) {
+        const message = current.editing?.reason.message
+            ?? 'The source layout is unavailable for editing.';
+        throw new TokenMutationError('AMBIGUOUS_SOURCE', message);
+    }
+    const documents = await TokenMutationDocuments.load(options, current);
+    const planner = new TokenMutationPlanner(options, current, documents, current.editing);
+    const changed = await planner.apply(mutation);
+    if (!changed) {
+        return {
+            compilation: current,
+            changes: [],
+            revision: current.revision,
+        };
+    }
+    const compilation = await compileProjectTokens({
+        ...options,
+        documents: documents.values,
+    });
+    if (!compilation.ok) {
+        throw new TokenMutationError('INVALID_MUTATION', 'The edit does not compile in every mode.', compilation);
+    }
+    validateMutationResult(current, compilation, mutation);
+    return {
+        compilation,
+        changes: documents.changes(),
+        revision: current.revision,
+    };
+}

package/dist/mutation/planner.d.ts

@@ -0,0 +1,11 @@
+import { type SupportedEditingProfile } from './layout.js';
+import type { TokenCompilation, TokenCompilationOptions } from '../compilation/compiler.js';
+import type { TokenMutationDocuments } from './documents.js';
+import type { TokenMutation } from './types.js';
+export declare class TokenMutationPlanner {
+    private readonly modes;
+    private readonly tokens;
+    constructor(options: Omit<TokenCompilationOptions, 'documents'>, compilation: TokenCompilation, documents: TokenMutationDocuments, profile: SupportedEditingProfile);
+    apply(mutation: TokenMutation): Promise<boolean>;
+}
+//# sourceMappingURL=planner.d.ts.map

package/dist/mutation/planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/mutation/planner.ts"],"names":[],"mappings":"AACA,OAAO,EAAuB,KAAK,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAKhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAC5F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qBAAa,oBAAoB;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IAEzC,YACI,OAAO,EAAE,IAAI,CAAC,uBAAuB,EAAE,WAAW,CAAC,EACnD,WAAW,EAAE,gBAAgB,EAC7B,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,uBAAuB,EAKnC;IAEK,KAAK,CAAC,QAAQ,EAAE,aAAa,oBAkDlC;CACJ"}

package/dist/mutation/planner.js

@@ -0,0 +1,67 @@
+import { isDtcgTokenType } from '../compilation/scope-validation.js';
+import { TokenMutationLayout } from './layout.js';
+import { TokenModeOperations } from './mode-operations.js';
+import { TokenOperations, validateTokenPath } from './token-operations.js';
+import { TokenMutationError } from './types.js';
+export class TokenMutationPlanner {
+    modes;
+    tokens;
+    constructor(options, compilation, documents, profile) {
+        const layout = new TokenMutationLayout(documents, profile);
+        this.modes = new TokenModeOperations(layout, compilation);
+        this.tokens = new TokenOperations(options, compilation, layout);
+    }
+    async apply(mutation) {
+        const path = 'path' in mutation
+            ? validateTokenPath(mutation.path)
+            : [];
+        switch (mutation.kind) {
+            case 'mode.create':
+                this.modes.create(mutation.mode);
+                return true;
+            case 'mode.default':
+                await this.modes.rebase(mutation.mode);
+                return true;
+            case 'mode.rename':
+                this.modes.rename(mutation.mode, mutation.to);
+                return true;
+            case 'mode.reset':
+                this.modes.reset(mutation.mode);
+                return true;
+            case 'mode.delete':
+                await this.modes.delete(mutation.mode);
+                return true;
+            case 'token.rename':
+            case 'group.rename':
+                this.tokens.rename(mutation, path);
+                return true;
+            case 'group.create':
+                this.tokens.createGroup(path);
+                return true;
+            case 'scope.create':
+                if (!isDtcgTokenType(mutation.type)) {
+                    throw new TokenMutationError('INVALID_SCOPE', 'Choose a standard DTCG type.');
+                }
+                this.tokens.createGroup(path, mutation.type);
+                return true;
+            case 'group.delete':
+                this.tokens.deleteGroup(mutation, path);
+                return true;
+            case 'token.duplicate':
+                this.tokens.duplicate(path, validateTokenPath(mutation.to));
+                return true;
+            case 'token.delete':
+                this.tokens.deleteToken(mutation.path, path);
+                return true;
+            case 'token.create':
+            case 'token.reset':
+            case 'token.update':
+                return this.tokens.edit(mutation, path);
+            default:
+                return assertNever(mutation);
+        }
+    }
+}
+function assertNever(value) {
+    throw new TokenMutationError('INVALID_MUTATION', `Unsupported token mutation: ${JSON.stringify(value)}`);
+}

package/dist/mutation/reference-renamer.d.ts

@@ -0,0 +1,25 @@
+import { TokenMutationDocuments } from './documents.js';
+import type { TokenCompilation, TokenCompilationOptions } from '../compilation/compiler.js';
+import type { TokenMutation } from './types.js';
+type RenameMutation = Extract<TokenMutation, {
+    kind: 'token.rename' | 'group.rename';
+}>;
+export declare class TokenReferenceRenamer {
+    private readonly options;
+    private readonly compilation;
+    private readonly documents;
+    private readonly modeFiles;
+    constructor(options: Omit<TokenCompilationOptions, 'documents'>, compilation: TokenCompilation, documents: TokenMutationDocuments, modeFiles: ReadonlyMap<string, string>);
+    rename(mutation: RenameMutation, sourcePath: string[], destinationPath: string[]): void;
+    private assertSource;
+    private moveDefinition;
+    private assertDestinationParents;
+    private findCompiledSource;
+    private assertScopeMove;
+    private rewriteReferences;
+    private rewriteDocumentReferences;
+    private renameReference;
+    private throwAmbiguous;
+}
+export {};
+//# sourceMappingURL=reference-renamer.d.ts.map

package/dist/mutation/reference-renamer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-renamer.d.ts","sourceRoot":"","sources":["../../src/mutation/reference-renamer.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAC5F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,KAAK,cAAc,GAAG,OAAO,CAAC,aAAa,EAAE;IAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAAA;CAAE,CAAC,CAAC;AAExF,qBAAa,qBAAqB;IAE1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJ9B,YACqB,OAAO,EAAE,IAAI,CAAC,uBAAuB,EAAE,WAAW,CAAC,EACnD,WAAW,EAAE,gBAAgB,EAC7B,SAAS,EAAE,sBAAsB,EACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACvD;IAEJ,MAAM,CAAC,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,eAAe,EAAE,MAAM,EAAE,QAmC/E;IAED,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,cAAc;IAkBtB,OAAO,CAAC,wBAAwB;IAUhC,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,iBAAiB;IAmBzB,OAAO,CAAC,yBAAyB;IAwEjC,OAAO,CAAC,eAAe;IA0DvB,OAAO,CAAC,cAAc;CAMzB"}

package/dist/mutation/reference-renamer.js

@@ -0,0 +1,186 @@
+import { relative, resolve, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { decodeJsonPointer, encodeJsonPointerPart, } from '../json-pointer.js';
+import { TokenMutationError } from './types.js';
+export class TokenReferenceRenamer {
+    options;
+    compilation;
+    documents;
+    modeFiles;
+    constructor(options, compilation, documents, modeFiles) {
+        this.options = options;
+        this.compilation = compilation;
+        this.documents = documents;
+        this.modeFiles = modeFiles;
+    }
+    rename(mutation, sourcePath, destinationPath) {
+        const group = mutation.kind === 'group.rename';
+        const files = [...this.modeFiles.values()].filter(file => (this.documents.read(file, sourcePath) !== undefined));
+        this.assertSource(files, sourcePath, group);
+        if (mutation.path === mutation.to) {
+            return;
+        }
+        if (group && mutation.to.startsWith(`${mutation.path}.`)) {
+            throw new TokenMutationError('INVALID_PATH', 'A group cannot move into itself.');
+        }
+        if ([...this.modeFiles.values()].some(file => (this.documents.read(file, destinationPath) !== undefined))) {
+            throw new TokenMutationError('PATH_EXISTS', 'The destination already exists.');
+        }
+        this.assertScopeMove(sourcePath, destinationPath, group);
+        for (const file of files) {
+            this.moveDefinition(file, sourcePath, destinationPath, mutation, group);
+        }
+        this.rewriteReferences(files, sourcePath, destinationPath);
+    }
+    assertSource(files, sourcePath, group) {
+        if (files.length === 0) {
+            throw new TokenMutationError(group ? 'GROUP_NOT_FOUND' : 'TOKEN_NOT_FOUND', 'The source path does not exist.');
+        }
+        const wrongKind = files.some(file => {
+            const source = this.documents.read(file, sourcePath);
+            return ('$value' in source) === group;
+        });
+        if (wrongKind) {
+            throw new TokenMutationError('INVALID_PATH', 'The source must match the requested token or group kind.');
+        }
+    }
+    moveDefinition(file, sourcePath, destinationPath, mutation, group) {
+        this.assertDestinationParents(file, destinationPath);
+        const moved = this.documents.read(file, sourcePath);
+        const original = this.findCompiledSource(file, mutation.path, group);
+        moved.$deprecated ??= original.deprecated;
+        this.documents.edit(file, destinationPath, moved);
+        this.documents.edit(file, sourcePath, undefined);
+    }
+    assertDestinationParents(file, destinationPath) {
+        for (let index = 1; index < destinationPath.length; index++) {
+            const parent = this.documents.read(file, destinationPath.slice(0, index));
+            if (parent && ('$value' in parent || '$extends' in parent)) {
+                this.throwAmbiguous();
+            }
+        }
+    }
+    findCompiledSource(file, path, group) {
+        const permutation = this.compilation.permutations.find(candidate => (this.modeFiles.get(candidate.input.mode) === file));
+        const nodes = group ? permutation?.groups : permutation?.tokens;
+        const source = nodes?.find(node => node.path === path);
+        if (!source) {
+            this.throwAmbiguous();
+        }
+        return source;
+    }
+    assertScopeMove(source, destination, group) {
+        if (group && source.length === 1 && destination.length === 1)
+            return;
+        if (group && (source.length === 1 || destination.length === 1 || source[0] !== destination[0])) {
+            throw new TokenMutationError('INVALID_SCOPE', 'Nested groups must stay inside their owning scope.');
+        }
+        const groups = this.compilation.permutations[0]?.groups ?? [];
+        const from = groups.find(candidate => candidate.path === source[0]);
+        const to = groups.find(candidate => candidate.path === destination[0]);
+        const parent = groups.find(candidate => candidate.path === destination.slice(0, -1).join('.'));
+        if (destination.length < 2 || !to?.type || !parent) {
+            throw new TokenMutationError('INVALID_SCOPE', 'Choose an existing group inside a typed scope.');
+        }
+        if (from?.type !== to.type) {
+            throw new TokenMutationError('SCOPE_TYPE_MISMATCH', `Cannot move ${from?.type} tokens into a ${to.type} scope.`);
+        }
+    }
+    rewriteReferences(sourceFiles, sourcePath, destinationPath) {
+        for (const file of this.documents.files) {
+            if (file === this.documents.entryFile) {
+                continue;
+            }
+            this.rewriteDocumentReferences(file, sourceFiles, sourcePath, destinationPath);
+        }
+    }
+    rewriteDocumentReferences(file, sourceFiles, sourcePath, destinationPath) {
+        const rewriteReference = (value, pointer) => this.renameReference(value, file, pointer, sourceFiles, sourcePath, destinationPath);
+        const visitValue = (node, path) => {
+            if (typeof node === 'string') {
+                const renamed = rewriteReference(node, false);
+                if (renamed !== node) {
+                    this.documents.edit(file, path, renamed);
+                }
+                return;
+            }
+            if (!node || typeof node !== 'object') {
+                return;
+            }
+            for (const [key, value] of Object.entries(node)) {
+                if (key === '$extensions') {
+                    continue;
+                }
+                const nextPath = [...path, Array.isArray(node) ? Number(key) : key];
+                if (key === '$ref' && typeof value === 'string') {
+                    const renamed = rewriteReference(value, true);
+                    if (renamed !== value) {
+                        this.documents.edit(file, nextPath, renamed);
+                    }
+                }
+                else {
+                    visitValue(value, nextPath);
+                }
+            }
+        };
+        const visitGroups = (node, path = []) => {
+            if (!node || typeof node !== 'object') {
+                return;
+            }
+            if ('$value' in node) {
+                visitValue(node.$value, [...path, '$value']);
+                return;
+            }
+            for (const [key, value] of Object.entries(node)) {
+                if (key === '$extends' && typeof value === 'string') {
+                    const renamed = rewriteReference(value, !value.startsWith('{'));
+                    if (renamed !== value) {
+                        this.documents.edit(file, [...path, key], renamed);
+                    }
+                }
+                else if (!key.startsWith('$') || key === '$root') {
+                    visitGroups(value, [...path, key]);
+                }
+            }
+        };
+        visitGroups(this.documents.parse(file));
+    }
+    renameReference(value, file, pointer, sourceFiles, sourcePath, destinationPath) {
+        const renamePath = (path) => {
+            const matches = sourcePath.every((part, index) => path[index] === part);
+            return matches
+                ? [...destinationPath, ...path.slice(sourcePath.length)]
+                : path;
+        };
+        if (!pointer) {
+            if (!/^\{[^{}]+\}$/.test(value)) {
+                return value;
+            }
+            const path = value.slice(1, -1).split('.');
+            return `{${renamePath(path).join('.')}}`;
+        }
+        const url = new URL(value, pathToFileURL(resolve(this.options.workspaceRoot, file)));
+        const target = new URL(url);
+        target.hash = '';
+        const targetFile = relative(resolve(this.options.workspaceRoot), fileURLToPath(target)).split(sep).join('/');
+        if (!value.startsWith('#') && !sourceFiles.includes(targetFile)) {
+            return value;
+        }
+        const fragment = decodeURIComponent(url.hash.slice(1));
+        if (!fragment.startsWith('/')) {
+            return value;
+        }
+        const path = decodeJsonPointer(fragment);
+        const renamed = renamePath(path);
+        if (renamed === path) {
+            return value;
+        }
+        const encoded = renamed
+            .map(part => `/${encodeURIComponent(encodeJsonPointerPart(part))}`)
+            .join('');
+        return `${value.split('#')[0]}#${encoded}`;
+    }
+    throwAmbiguous() {
+        throw new TokenMutationError('AMBIGUOUS_SOURCE', 'Structured editing requires independent local token documents. Edit this layout in JSON.');
+    }
+}