@everyprotocol/every-cli 0.1.3 → 0.1.5

package/dist/program.js

@@ -1,41 +1,30 @@
 import { Command } from "commander";
-import { generateCommands } from "./cmdgen.js";
-import { RenamingCommand } from "./cmds.js";
 import { version } from "./utils.js";
-import { walletCmd } from "./wallet.js";
-import { genMatterCommand } from "./matter.js";
-function buildProgram() {
-    const subCmds = generateCommands();
-    const kindCmd = new RenamingCommand().name("kind").description("manage kinds").addCommands(subCmds.kind);
-    const setCmd = new RenamingCommand().name("set").description("manage sets").addCommands(subCmds.set);
-    const relationCmd = new RenamingCommand()
-        .name("relation")
-        .description("manage relations")
-        .addCommands(subCmds.relation);
-    const uniqueCmd = new RenamingCommand().name("unique").description("manage uniques").addCommands(subCmds.unique);
-    const valueCmd = new RenamingCommand().name("value").description("manage values").addCommands(subCmds.value);
-    const objectCmd = new RenamingCommand()
-        .name("object")
-        .description("create and interact with objects")
-        .addCommands(subCmds.object);
-    const mintPolicyCmd = new RenamingCommand()
-        .name("minter")
-        .description("manage mint policies")
-        .addCommands(subCmds.mintpolicy);
-    const program = new Command()
-        .name("every")
-        .description("CLI for interacting with Every Protocol")
-        .version(version())
-        .showHelpAfterError(true);
-    program.addCommand(genMatterCommand());
-    program.addCommand(setCmd);
-    program.addCommand(kindCmd);
-    program.addCommand(relationCmd);
-    program.addCommand(valueCmd);
-    program.addCommand(uniqueCmd);
-    program.addCommand(objectCmd);
-    program.addCommand(mintPolicyCmd);
-    program.addCommand(walletCmd);
-    return program;
-}
-export const program = buildProgram();
+import { walletCmd } from "./cmds/wallet.js";
+import { matterCmd } from "./cmds/matter.js";
+import { balanceCmd } from "./cmds/balance.js";
+import { configCmd } from "./cmds/config.js";
+import { kindCmd } from "./cmds/kind.js";
+import { valueCmd } from "./cmds/value.js";
+import { uniqueCmd } from "./cmds/unique.js";
+import { relationCmd } from "./cmds/relation.js";
+import { setCmd } from "./cmds/set.js";
+import { objectCmd } from "./cmds/object.js";
+import { minterCmd } from "./cmds/minter.js";
+import { universeCmd } from "./cmds/universe.js";
+export const program = new Command("every")
+    .description("CLI for interacting with Every Protocol")
+    .version(version())
+    .showHelpAfterError(true)
+    .addCommand(universeCmd)
+    .addCommand(matterCmd)
+    .addCommand(setCmd)
+    .addCommand(kindCmd)
+    .addCommand(relationCmd)
+    .addCommand(valueCmd)
+    .addCommand(uniqueCmd)
+    .addCommand(objectCmd)
+    .addCommand(minterCmd)
+    .addCommand(balanceCmd)
+    .addCommand(walletCmd)
+    .addCommand(configCmd);

package/dist/substrate.js

@@ -1,19 +1,11 @@
 import "@polkadot/api-augment/substrate";
 import { decodeAddress } from "@polkadot/util-crypto";
 import { u8aFixLength } from "@polkadot/util";
-import "./options.js";
-function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return { promise, resolve, reject };
-}
+import * as JSON11 from "json11";
+import columify from "columnify";
+import { createDeferred } from "./utils.js";
+import "./commander-patch.js";
 export async function submitTransaction(api, tx, pair) {
-    // const pTxn = Promise.withResolvers<Transaction>();
-    // const pReceipt = Promise.withResolvers<Receipt>();
     const pTxn = createDeferred();
     const pReceipt = createDeferred();
     const accountId = u8aFixLength(decodeAddress(pair.address), 256);
@@ -47,11 +39,25 @@ export async function submitTransaction(api, tx, pair) {
     });
     return await pTxn.promise;
 }
-export function findEvent(events, name) {
-    for (const record of events) {
-        if (record.event && record.event.method === name) {
-            return record.event;
-        }
+export async function submitSubTxUI(api, tx, pair, console) {
+    console.log(`Transaction submitting...`);
+    const txn = await submitTransaction(api, tx, pair);
+    console.log(`Transaction submitted: ${txn.txHash}`);
+    console.log("Waiting for confirmation...");
+    const r = await txn.receipt;
+    const header = await api.rpc.chain.getHeader(r.blockHash);
+    console.log(`Confirmed in: block ${header.number}, hash ${header.hash}`);
+    const events = r.events.map((e, i) => [i, e.event.method, JSON11.stringify(e.event.data.toJSON())]);
+    const result = r.events.map((e) => {
+        const event = {
+            event: e.event.method,
+            data: e.event.data.toJSON(),
+        };
+        return event;
+    });
+    if (events.length > 0) {
+        console.log(`Events`);
+        console.log(columify(events, { showHeaders: false }));
     }
-    return undefined;
+    console.result(result);
 }

package/dist/utils.js

@@ -1,127 +1,25 @@
-import { bytesToHex, createPublicClient, createWalletClient, encodeAbiParameters, http, } from "viem";
-import { formatAbiParameter } from "abitype";
 import fs from "fs";
 import path from "path";
-import { Wallet } from "ethers";
-import { privateKeyToAccount } from "viem/accounts";
-import promptSync from "prompt-sync";
-import os from "os";
-import JSON5 from "json5";
 import { fileURLToPath } from "url";
 import { isHex, hexToU8a } from "@polkadot/util";
 import { base64Decode } from "@polkadot/util-crypto/base64";
 import { decodePair } from "@polkadot/keyring/pair/decode";
-import { loadMergedConfig } from "./config.js";
-import Keyring from "@polkadot/keyring";
-import { UnifiedKeystore } from "./keystore.js";
+import { getAddress, isAddress } from "viem";
+import { FromOpts } from "./from-opts.js";
 export const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export function version() {
     const pkgPath = path.resolve(__dirname, "../package.json");
     return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
 }
-export function lstrip(prefix) {
-    return function (func) {
-        return func.name.startsWith(prefix) ? func.name.substring(prefix.length).toLowerCase() : func.name;
-    };
-}
-export function rstrip(postfix) {
-    return function (func) {
-        return func.name.endsWith(postfix) ? func.name.slice(0, -postfix.length) : func.name;
-    };
-}
-export function startsWith(prefix) {
-    return function (func) {
-        return func.name.startsWith(prefix);
-    };
-}
-export function excludes(names) {
-    return function (func) {
-        return !names.includes(func.name);
-    };
-}
-export function includes(names) {
-    return function (f) {
-        return names.includes(f.name);
-    };
-}
-export function stringify(o) {
-    const replacer = (_key, value) => (typeof value === "bigint" ? value.toString() : value);
-    return JSON5.stringify(o, replacer);
-}
-export async function getClientsEth(uniConf, opts) {
-    const transport = http(uniConf.rpc);
-    const publicClient = createPublicClient({ transport });
-    const privateKey = await readPrivateKeyEth(opts);
-    const account = privateKeyToAccount(privateKey);
-    const walletClient = createWalletClient({ account, transport });
-    return { publicClient, walletClient };
-}
-export async function readPrivateKeyEth(opts) {
-    if (opts.privateKey) {
-        return opts.privateKey.startsWith("0x") ? opts.privateKey : `0x${opts.privateKey}`;
-    }
-    else if (opts.account) {
-        const keystorePath = resolveKeystoreFile(opts.account, opts);
-        const keystore = loadKeystore(keystorePath);
-        if (keystore.crypto || keystore.Crypto) {
-            // for Ethereum keystores
-            const password = getPassword(opts);
-            const wallet = await Wallet.fromEncryptedJson(JSON.stringify(keystore), password);
-            return wallet.privateKey;
-        }
-        else if (keystore.encoding || keystore.meta) {
-            // for Substrate keystores
-            if (keystore.meta?.isEthereum || keystore.meta?.type === "ethereum") {
-                const password = getPassword(opts);
-                const pair = decodeSubstratePair(keystore, password);
-                return bytesToHex(pair.secretKey);
-            }
-            else {
-                throw new Error("Not an Ethereum account");
-            }
-        }
-        else {
-            // Not supported for now
-            throw new Error("Unknown keystore format");
-        }
-    }
-    else {
-        throw new Error(`Neither account nor private key specified`);
-    }
-}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function checkArguments(raw, func) {
-    return raw.map((rawArg, index) => {
-        const abiParam = func.inputs[index];
-        const pt = abiParam?.type;
-        const arg = pt === "address" || pt.startsWith("bytes") || pt === "string" ? rawArg : JSON5.parse(rawArg);
-        try {
-            encodeAbiParameters([abiParam], [arg]);
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                throw new Error(`invalid param ${formatAbiParameter(abiParam)}\n${e.message}`);
-            }
-        }
-        return arg;
-    });
-}
-export function resolveKeystoreDir(options) {
-    if (options.foundry) {
-        return path.join(os.homedir(), ".foundry", "keystores");
-    }
-    if (options.dir) {
-        return options.dir;
+export function loadJson(file) {
+    if (!fs.existsSync(file)) {
+        throw new Error(`Keystore file not found: ${file}`);
     }
-    return path.join(os.homedir(), ".every", "keystores");
-}
-export function resolveKeystoreFile(name, options) {
-    const dir = resolveKeystoreDir(options);
-    return path.join(dir, name);
+    return JSON.parse(fs.readFileSync(file, "utf8"));
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function saveKeystore(json, name, options) {
-    const dir = resolveKeystoreDir(options);
+// eslint-disable-next-line
+export function saveJson(json, dir, name) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
@@ -130,39 +28,9 @@ export function saveKeystore(json, name, options) {
         throw new Error(`File exists: ${file}`);
     }
     fs.writeFileSync(file, JSON.stringify(json));
-    console.log(`File saved: ${file}`);
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function loadKeystore(file) {
-    if (!fs.existsSync(file)) {
-        throw new Error(`Keystore file not found: ${file}`);
-    }
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-}
-export function getPassword(opts) {
-    return opts.password
-        ? opts.password
-        : opts.passwordFile
-            ? fs.readFileSync(opts.passwordFile, "utf8").trim()
-            : promptSync({ sigint: true })("Password: ", { echo: "" });
-}
-export function getPasswordConfirm(opts) {
-    if (opts.password) {
-        return opts.password;
-    }
-    if (opts.passwordFile) {
-        return fs.readFileSync(opts.passwordFile, "utf8").trim();
-    }
-    const prompt = promptSync({ sigint: true });
-    const password = prompt("Password: ", { echo: "" });
-    const confirmation = prompt("Confirm: ", { echo: "" });
-    if (password !== confirmation) {
-        throw new Error(`Error: Passwords do not match`);
-    }
-    return password;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function decodeSubstratePair(keystore, password) {
+export function decodePairFromJson(keystore, password) {
     const encodedRaw = keystore.encoded;
     let encodingType = keystore.encoding.type;
     encodingType = !Array.isArray(encodingType) ? [encodingType] : encodingType;
@@ -170,53 +38,132 @@ export function decodeSubstratePair(keystore, password) {
     const decoded = decodePair(password, encoded, encodingType);
     return decoded;
 }
-export function getSubstrateAccountPair(flags) {
-    const keyFile = resolveKeystoreFile(flags.account, flags);
-    const keyData = loadKeystore(keyFile);
-    const keyring = new Keyring();
-    const pair = keyring.createFromJson(keyData);
-    if (pair.isLocked) {
-        const password = getPassword(flags);
-        pair.unlock(password);
-    }
-    return pair;
-}
-export async function keystoreFromOptions(options) {
-    if (!options.account) {
-        throw new Error("Account must be specified with --account");
-    }
-    return keystoreFromAccount(options.account, options);
-}
-export async function keystoreFromAccount(account, options) {
-    const file = resolveKeystoreFile(account, options);
-    const keyData = loadKeystore(file);
-    const password = getPassword(options);
-    const keystore = await UnifiedKeystore.fromJSON(keyData, password);
-    return keystore;
-}
-export function getObserverConfig(options) {
-    const conf = loadMergedConfig();
-    let observerName;
-    const DEFAULT_OBSERVER = "localnet";
-    if (options.observer) {
-        observerName = options.observer;
+export function guessContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case ".txt":
+            return "text/plain";
+        case ".json":
+            return "application/json";
+        case ".wasm":
+            return "application/wasm";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        default:
+            return "application/octet-stream";
+    }
+}
+export function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+const isArrayType = (t) => /\[[^\]]*\]$/.test(t);
+const isTupleType = (t) => t.startsWith("tuple");
+const elemType = (t) => t.replace(/\[[^\]]*\]$/, "");
+// const fmtInputs = (ins: ReadonlyArray<Pick<AbiParameter, "name" | "type">>) =>
+//   ins.map((i) => (i.name ? `${i.type} ${i.name}` : i.type)).join(", ");
+function hasComponents(p) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return p.components !== "undefined";
+}
+function coerceScalar(val, type) {
+    const base = elemType(type);
+    if (base === "address") {
+        if (!isAddress(val))
+            throw new Error(`Invalid address: ${val}`);
+        return getAddress(val);
+    }
+    if (base === "bool") {
+        if (!/^(true|false)$/i.test(val))
+            throw new Error(`Invalid bool: ${val}`);
+        return /^true$/i.test(val);
+    }
+    if (base === "string")
+        return val;
+    if (base.startsWith("bytes")) {
+        if (!/^0x[0-9a-fA-F]*$/.test(val))
+            throw new Error(`Invalid ${base} (expect 0x...)`);
+        return val;
+    }
+    if (base.startsWith("uint") || base.startsWith("int")) {
+        try {
+            return val.startsWith("0x") ? BigInt(val) : BigInt(val);
+        }
+        catch {
+            throw new Error(`Invalid ${base}: ${val}`);
+        }
     }
-    else if (options.universe) {
-        const universe = conf.universes[options.universe];
-        if (!universe) {
-            throw new Error(`Universe '${options.universe}' not found in config. Available: ${Object.keys(conf.universes).join(", ")}`);
+    return val;
+}
+export function coerceValue(val, param) {
+    const { type } = param;
+    // arrays: expect JSON array; recurse on element type (preserve components if tuple[])
+    if (isArrayType(type)) {
+        const arr = JSON.parse(val);
+        if (!Array.isArray(arr))
+            throw new Error(`Expected array for ${type}`);
+        // build element param (carry tuple components if present)
+        const inner = hasComponents(param)
+            ? { ...param, type: elemType(type), components: param.components }
+            : { ...param, type: elemType(type) };
+        return arr.map((v) => coerceValue(typeof v === "string" ? v : JSON.stringify(v), inner));
+    }
+    // tuples: need components
+    if (isTupleType(type)) {
+        if (!hasComponents(param) || param.components.length === 0) {
+            throw new Error(`Tuple components missing for ${type}`);
+        }
+        const tup = JSON.parse(val);
+        if (Array.isArray(tup)) {
+            if (tup.length !== param.components.length) {
+                throw new Error(`Tuple length mismatch: expected ${param.components.length}, got ${tup.length}`);
+            }
+            return param.components.map((c, i) => coerceValue(typeof tup[i] === "string" ? tup[i] : JSON.stringify(tup[i]), c));
         }
-        observerName = universe.observer;
+        // object by names
+        return param.components.map((c) => {
+            const v = tup[c.name];
+            if (v === undefined)
+                throw new Error(`Tuple field missing: ${c.name}`);
+            return coerceValue(typeof v === "string" ? v : JSON.stringify(v), c);
+        });
     }
-    else {
-        observerName = DEFAULT_OBSERVER;
+    // scalar
+    return coerceScalar(val, type);
+}
+export async function substrateAction(cmd, api, fn) {
+    try {
+        return await fn(api);
     }
-    if (!observerName) {
-        throw new Error(`No observer resolved from options or config.`);
+    catch (e /* eslint-disable-line */) {
+        cmd.error(e.message);
     }
-    const observer = conf.observers[observerName];
-    if (!observer) {
-        throw new Error(`Observer '${observerName}' not found in config. Available: ${Object.keys(conf.observers).join(", ")}`);
+    finally {
+        api.disconnect().catch(() => { });
     }
-    return observer;
+}
+export function wrapSubAction(fn) {
+    // eslint-disable-next-line
+    return async function (...args) {
+        const api = await FromOpts.getSubstrateApi(this.opts());
+        try {
+            // keep Commander’s `this` binding and pass api first
+            return await fn.call(this, api, ...args);
+        }
+        finally {
+            await api.disconnect().catch(() => { });
+        }
+    };
+}
+export function loadBinary(file) {
+    const buf = fs.readFileSync(file);
+    return buf;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@everyprotocol/every-cli",
   "type": "module",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "files": [
     "dist/",
     "abis/",
@@ -15,6 +15,7 @@
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@types/bun": "latest",
+    "@types/columnify": "^1.5.4",
     "@types/lodash-es": "^4.17.12",
     "@types/prompt-sync": "^4.2.3",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
@@ -32,8 +33,11 @@
     "@polkadot/keyring": "^13.5.2",
     "@polkadot/util": "^13.5.2",
     "@polkadot/util-crypto": "^13.5.2",
+    "columnify": "^1.6.0",
     "commander": "^13.1.0",
+    "csv-parser": "^3.2.0",
     "ethers": "^6.14.0",
+    "json11": "^2.0.2",
     "json5": "^2.2.3",
     "lodash-es": "^4.17.21",
     "prompt-sync": "^4.2.0",

package/dist/cmds.js

@@ -1,132 +0,0 @@
-import { Argument, Command, Option } from "commander";
-import { createPublicClient, http, parseEventLogs, stringify } from "viem";
-import { getUniverseConfig } from "./config.js";
-import { checkArguments, getClientsEth } from "./utils.js";
-export function defaultReadFunctionOptions() {
-    const options = [];
-    options.push(new Option("-u, --universe <universe>", "universe name").default("local"));
-    options.push(new Option("--dry-run", "Simulate the command without sending a transaction"));
-    return options;
-}
-export function defaultWriteFunctionOptions() {
-    const options = [];
-    options.push(new Option("-u, --universe <universe>", "universe name").default("local"));
-    options.push(new Option("-k, --private-key <key>", "private key to sign the transaction"));
-    options.push(new Option("-a, --account <account>", "name of the keystore to sign the transaction"));
-    options.push(new Option("-p, --password [password]", "password to decrypt the keystore"));
-    options.push(new Option("--password-file <file>", "file containing the password to decrypt the keystore"));
-    options.push(new Option("-f, --foundry", "use keystore from Foundry directory (~/.foundry/keystores)"));
-    options.push(new Option("--dry-run", "Simulate the command without sending a transaction"));
-    return options;
-}
-const defaultConfig = {
-    cmdAbi: (txnAbi) => txnAbi,
-    cmdName: (cmdAbi) => cmdAbi.name,
-    cmdDescription: (cmdAbi) => cmdAbi._metadata?.notice || cmdAbi.name,
-    cmdOptions: (cmdAbi) => {
-        const read = cmdAbi.stateMutability == "view" || cmdAbi.stateMutability == "pure";
-        return read ? defaultReadFunctionOptions() : defaultWriteFunctionOptions();
-    },
-    cmdArguments: (cmdAbi) => cmdAbi.inputs.map((input) => {
-        const argDesc = cmdAbi._metadata?.params?.[input.name] || `${input.type} parameter`;
-        return new Argument(`<${input.name}>`, argDesc);
-    }),
-    cmdAction: async function (ctx) {
-        const isRead = ctx.cmdAbi.stateMutability == "view" || ctx.cmdAbi.stateMutability == "pure";
-        const opts = ctx.cmd.opts();
-        const args0 = ctx.cmd.args;
-        console.log({ args0 });
-        const { address, tag, args } = await ctx.txnPrepare(ctx);
-        const abi = [ctx.txnAbi, ...ctx.nonFuncs];
-        const functionName = ctx.txnAbi.name;
-        if (isRead) {
-            const publicClient = createPublicClient({ transport: http(ctx.conf.rpc) });
-            const result = await publicClient.readContract({ address, abi, functionName, args });
-            console.log(`Result:`, result);
-        }
-        else {
-            const { publicClient, walletClient } = await getClientsEth(ctx.conf, opts);
-            const account = walletClient.account;
-            console.log({
-                isRead,
-                address: `${address} (${tag})`,
-                account: account?.address,
-                signature: ctx.txnAbi._metadata.signature,
-                args,
-            });
-            const { request } = await publicClient.simulateContract({ address, abi, functionName, args, account });
-            const hash = await walletClient.writeContract(request);
-            console.log(`Transaction sent: ${hash}`);
-            console.log("Transaction mining...");
-            const receipt = await publicClient.waitForTransactionReceipt({ hash });
-            console.log("Transaction mined");
-            if (receipt.logs && receipt.logs.length > 0) {
-                const parsedLogs = parseEventLogs({ abi, logs: receipt.logs });
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                parsedLogs.forEach((log) => {
-                    console.log(" - Event", log.eventName, stringify(log.args));
-                });
-            }
-        }
-        console.log({ isRead, address: `${address} (${tag})`, signature: ctx.txnAbi._metadata.signature, args });
-        return;
-    },
-    txnPrepare: function (ctx) {
-        const args = checkArguments(ctx.cmd.args, ctx.cmdAbi);
-        return { address: ctx.conf.contracts[ctx.contract], tag: ctx.contract, args };
-    },
-};
-export function configureCommand(txnAbi, config) {
-    const cmdAbi = (config.cmdAbi || defaultConfig.cmdAbi)(txnAbi);
-    const name = (config.cmdName || defaultConfig.cmdName)(cmdAbi);
-    const desc = (config.cmdDescription || defaultConfig.cmdDescription)(cmdAbi);
-    const opts = (config.cmdOptions || defaultConfig.cmdOptions)(cmdAbi);
-    const args = (config.cmdArguments || defaultConfig.cmdArguments)(cmdAbi);
-    const action = async function () {
-        const ctx = {
-            conf: getUniverseConfig(this.opts()),
-            contract: config.contract,
-            cmdAbi,
-            txnAbi,
-            nonFuncs: config.nonFuncs,
-            cmd: this,
-            txnPrepare: config.txnPrepare || defaultConfig.txnPrepare,
-        };
-        await (config.cmdAction || defaultConfig.cmdAction)(ctx);
-    };
-    const cmd = new Command();
-    cmd.name(name);
-    cmd.description(desc);
-    opts.forEach((opt) => cmd.addOption(opt));
-    args.forEach((arg) => cmd.addArgument(arg));
-    cmd.action(action);
-    return cmd;
-}
-export class RenamingCommand extends Command {
-    nameCounts = new Map();
-    addCommand(cmd, opts) {
-        const originalName = cmd.name();
-        const uniqueName = this.getUniqueName(originalName);
-        if (originalName !== uniqueName) {
-            cmd.name(uniqueName);
-        }
-        return super.addCommand(cmd, opts);
-    }
-    addCommands(cmds) {
-        cmds.forEach((cmd) => this.addCommand(cmd));
-        return this;
-    }
-    resetCounts(name) {
-        if (name) {
-            this.nameCounts.delete(name);
-        }
-        else {
-            this.nameCounts.clear();
-        }
-    }
-    getUniqueName(baseName) {
-        const count = this.nameCounts.get(baseName) || 0;
-        this.nameCounts.set(baseName, count + 1);
-        return count === 0 ? baseName : `${baseName}${count + 1}`;
-    }
-}