framer-code-link 0.4.1 → 0.4.2

package/dist/index.mjs

@@ -5,7 +5,6 @@ import fs from "fs/promises";
 import { WebSocketServer } from "ws";
 import chokidar from "chokidar";
 import path from "path";
-import { getPortFromHash, isSupportedExtension, normalizePath, pluralize, sanitizeFilePath, shortProjectHash } from "@code-link/shared";
 import { createHash } from "crypto";
 import { setupTypeAcquisition } from "@typescript/ata";
 import ts from "typescript";
@@ -419,6 +418,173 @@ function sendMessage(socket, message) {
 	});
 }
 
+//#endregion
+//#region ../code-link-shared/src/hash.ts
+/**
+* Base58 alphabet (no 0/O/I/l to avoid confusion)
+*/
+const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+/**
+* Derive a short, deterministic hash from the full Framer project hash.
+* Uses a simple numeric hash encoded in base58 for compactness.
+* Idempotent: if input is already the target length, returns it unchanged.
+*/
+function shortProjectHash(fullHash, length = 8) {
+	if (fullHash.length === length) return fullHash;
+	let h1 = 0;
+	let h2 = 0;
+	for (let i = 0; i < fullHash.length; i++) {
+		const char = fullHash.charCodeAt(i);
+		h1 = Math.imul(h1 ^ char, 2246822507);
+		h2 = Math.imul(h2 ^ char, 3266489909);
+	}
+	h1 ^= h2 >>> 16;
+	h2 ^= h1 >>> 13;
+	let result = "";
+	const combined = [Math.abs(h1), Math.abs(h2)];
+	for (const num of combined) {
+		let n = num >>> 0;
+		while (n > 0 && result.length < length) {
+			result += BASE58[n % 58];
+			n = Math.floor(n / 58);
+		}
+	}
+	while (result.length < length) result += BASE58[0];
+	return result.slice(0, length);
+}
+
+//#endregion
+//#region ../code-link-shared/src/ports.ts
+/**
+* Generate a deterministic port number from a project hash (full or short).
+* Port range: 3847-4096 (250 possible ports)
+* Must match between CLI and plugin.
+*
+* Internally normalizes to the short id so both full and short inputs yield the same port.
+*/
+function getPortFromHash(projectHash) {
+	const shortId = shortProjectHash(projectHash);
+	let hash = 0;
+	for (let i = 0; i < shortId.length; i++) {
+		const char = shortId.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return 3847 + Math.abs(hash) % 250;
+}
+
+//#endregion
+//#region ../code-link-shared/src/paths.ts
+/**
+* File path normalization utilities
+* Framer code files include extensions in their paths (.tsx, .ts, etc.)
+*/
+const firstCharacterRegex = /^[a-zA-Z$_]/;
+const remainingCharactersRegex = /[^a-zA-Z0-9$_]/g;
+const onlyDotsRegex = /^\.+$/;
+const tsxExtension = ".tsx";
+var NameType = /* @__PURE__ */ function(NameType$1) {
+	NameType$1["Variable"] = "Variable";
+	NameType$1["Selector"] = "Selector";
+	NameType$1["Directory"] = "Directory";
+	return NameType$1;
+}(NameType || {});
+function sanitizedName(type, name) {
+	if (!name) return null;
+	let validName = name.trim();
+	if (validName.length === 0) return null;
+	const validFirstChar = type === NameType.Selector ? "_" : "$";
+	if (type === NameType.Directory) {
+		if (onlyDotsRegex.test(validName)) return null;
+	} else if (!firstCharacterRegex.test(validName)) validName = validFirstChar + validName;
+	validName = validName.replace(remainingCharactersRegex, "_");
+	validName = validName.replace(/_+/g, "_");
+	validName = validName.replace(/^\$_/u, validFirstChar);
+	return validName;
+}
+function sanitizedVariableName(name) {
+	return sanitizedName(NameType.Variable, name);
+}
+function sanitizedDirectoryName(name) {
+	return sanitizedName(NameType.Directory, name);
+}
+function capitalizeFirstLetter(str) {
+	if (str.length === 0) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function hasValidExtension(fileName) {
+	if (fileName.endsWith(".json")) return true;
+	return /\.[tj]sx?$/u.test(fileName);
+}
+function splitExtension(fileName) {
+	const lastDot = fileName.lastIndexOf(".");
+	if (lastDot <= 0) return [fileName, ""];
+	return [fileName.slice(0, lastDot), fileName.slice(lastDot + 1)];
+}
+function dirname(filePath) {
+	const at = filePath.lastIndexOf("/");
+	if (at < 0) return "";
+	return filePath.slice(0, at);
+}
+function filename(filePath) {
+	const at = filePath.lastIndexOf("/") + 1;
+	return filePath.slice(at);
+}
+function pathJoin(...parts) {
+	let res = "";
+	parts.forEach((part) => {
+		while (part.startsWith("/")) part = part.slice(1);
+		while (part.endsWith("/")) part = part.slice(0, -1);
+		if (part === "") return;
+		if (res !== "") res += "/";
+		res += part;
+	});
+	return res;
+}
+function normalizePath(filePath) {
+	if (!filePath) return "";
+	const isAbsolute = filePath.startsWith("/");
+	const segments = filePath.replace(/\\/g, "/").split("/");
+	const stack = [];
+	for (const segment of segments) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length > 0) stack.pop();
+			continue;
+		}
+		stack.push(segment);
+	}
+	const normalized = stack.join("/");
+	if (isAbsolute) return `/${normalized}`;
+	return normalized;
+}
+function sanitizeFilePath(input, capitalizeReactComponent = true) {
+	const trimmed = input.trim();
+	const [inputName, extension] = splitExtension(filename(trimmed));
+	const extensionWithDot = extension ? `.${extension}` : "";
+	const dirName = dirname(trimmed).split("/").map((part) => sanitizedDirectoryName(part)).filter((part) => Boolean(part)).join("/");
+	let name = sanitizedVariableName(inputName) ?? "MyComponent";
+	if ((!hasValidExtension(extension) || extension === tsxExtension) && capitalizeReactComponent) name = capitalizeFirstLetter(name);
+	return {
+		path: pathJoin(dirName, name + extensionWithDot),
+		dirName,
+		name,
+		extension
+	};
+}
+function isSupportedExtension$1(filePath) {
+	return /\.(tsx?|jsx?|json)$/i.test(filePath);
+}
+/**
+* Pluralize a word based on count
+* @example pluralize(1, "file") => "1 file"
+* @example pluralize(3, "file") => "3 files"
+* @example pluralize(0, "conflict") => "0 conflicts"
+*/
+function pluralize(count, singular, plural) {
+	return `${count} ${count === 1 ? singular : plural ?? `${singular}s`}`;
+}
+
 //#endregion
 //#region src/utils/node-paths.ts
 /**
@@ -473,7 +639,7 @@ function initWatcher(filesDir) {
 	});
 	debug(`Watching directory: ${filesDir}`);
 	const emitEvent = async (kind, absolutePath) => {
-		if (!isSupportedExtension(absolutePath)) return;
+		if (!isSupportedExtension$1(absolutePath)) return;
 		const rawRelativePath = normalizePath(getRelativePath(filesDir, absolutePath));
 		const relativePath = sanitizeFilePath(rawRelativePath, false).path;
 		let effectiveAbsolutePath = absolutePath;
@@ -637,7 +803,7 @@ async function listFiles(filesDir) {
 				await walk(entryPath);
 				continue;
 			}
-			if (!isSupportedExtension$1(entry.name)) continue;
+			if (!isSupportedExtension(entry.name)) continue;
 			const sanitizedPath = sanitizeFilePath(normalizePath(path.relative(filesDir, entryPath)), false).path;
 			try {
 				const [content, stats] = await Promise.all([fs.readFile(entryPath, "utf-8"), fs.stat(entryPath)]);
@@ -888,7 +1054,7 @@ function sanitizeRelativePath(relativePath) {
 		extension: sanitized.extension || path.extname(normalized) || DEFAULT_EXTENSION
 	};
 }
-function isSupportedExtension$1(fileName) {
+function isSupportedExtension(fileName) {
 	const lower = fileName.toLowerCase();
 	return SUPPORTED_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framer-code-link",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "CLI tool for syncing Framer code components - controller-centric architecture",
   "main": "dist/index.mjs",
   "type": "module",
@@ -10,7 +10,7 @@
   ],
   "scripts": {
     "dev": "NODE_ENV=development tsx src/index.ts",
-    "build": "tsdown src/index.ts",
+    "build": "tsdown",
     "start": "node dist/index.mjs",
     "test": "vitest run"
   },