@appartmint/tsm-scripts 0.0.1 → 0.0.2

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@appartmint/tsm-scripts",
 	"author": "App Art Mint LLC",
-	"version": "0.0.1",
+	"version": "0.0.2",
 	"type": "module",
 	"license": "MIT",
-	"description": "TypeScript Modules from App Art Mint LLC",
+	"description": "TypeScript Node Scripts from App Art Mint LLC",
 	"keywords": [
 		"typescript",
 		"modules",
@@ -25,16 +25,8 @@
 		"access": "public"
 	},
 	"files": [
-		"dist/**/*.{js,d.ts}"
+		"src/**/*.{ts,d.ts}"
 	],
-	"exports": {
-		"./*": {
-			"types": "./dist/*.d.ts",
-			"import": "./dist/*.es.js",
-			"require": "./dist/*.cjs.js",
-			"default": "./dist/*.es.js"
-		}
-	},
 	"scripts": {
 		"version": "npm i && git add -A",
 		"postversion": "git push && git push --tags && cross-replace gh release create \"v$npm_package_version\" --generate-notes",

package/src/format/organize-imports-comments.ts

@@ -0,0 +1,202 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as ts from 'typescript';
+
+const rootArg = process.argv[2];
+const ROOT = rootArg ? path.resolve(rootArg) : process.cwd();
+const SRC = path.join(ROOT, 'src');
+
+type ImportGroup = 'external' | 'workspace' | 'local' | 'environment';
+
+interface ParsedImport {
+	spec: string;
+	group: ImportGroup;
+	finalText: string;
+	multi: boolean;
+}
+
+function walkTsFiles(dir: string, out: string[] = []): string[] {
+	for (const name of fs.readdirSync(dir, { withFileTypes: true })) {
+		const p = path.join(dir, name.name);
+		if (name.isDirectory()) walkTsFiles(p, out);
+		else if (name.isFile() && name.name.endsWith('.ts')) out.push(p);
+	}
+	return out;
+}
+
+const FROM_RE = /from\s+(['"])([^'"]+)\1/;
+
+function getModuleSpecifier(text: string): string {
+	const m = FROM_RE.exec(text);
+	return m ? m[2] : '';
+}
+
+function classify(spec: string): ImportGroup {
+	if (!spec) return 'external';
+	if (spec.includes('/environments/') || spec.includes('environments/environment')) return 'environment';
+	if (spec.startsWith('@app-art-mint/') || spec.startsWith('@appartmint/')) return 'workspace';
+	if (spec.startsWith('.') || spec.startsWith('..')) return 'local';
+	return 'external';
+}
+
+function groupOrder(g: ImportGroup): number {
+	const order: Record<ImportGroup, number> = { external: 0, workspace: 1, local: 2, environment: 3 };
+	return order[g];
+}
+
+function isMultiLineImport(text: string): boolean {
+	return text.includes('\n');
+}
+
+function fileUsesSemicolon(sourceText: string, importTexts: string[]): boolean {
+	if (importTexts.some((t) => /;\s*$/.test(t))) return true;
+	const sample = sourceText.slice(0, 2000);
+	return /import[^;]+;\s*\n/.test(sample);
+}
+
+function normalizeImportLine(text: string): string {
+	let s = text.replace(/\s+/g, ' ').replace(/;+\s*$/, '').trim();
+	s = s.replace(/,\s*\}(?=\s+from\s+)/g, ' }');
+	s = s.replace(/([\w$])}(?=\s+from\s+)/g, '$1 }');
+	return s;
+}
+
+function ensureSemicolon(text: string, semicolon: boolean): string {
+	const t = text.replace(/;+\s*$/, '').trimEnd();
+	return semicolon ? `${t};` : t;
+}
+
+function wrapImportIfNeeded(text: string, maxLen: number, semicolon: boolean): string {
+	const normalized = normalizeImportLine(text);
+	if (normalized.length <= maxLen) return ensureSemicolon(normalized, semicolon);
+
+	const fromMatch = /^(.+?)\s+from\s+(['"][^'"]+['"])$/.exec(normalized);
+	if (!fromMatch) return ensureSemicolon(normalized, semicolon);
+
+	const head = fromMatch[1].trim();
+	const fromPart = fromMatch[2];
+	const m = /^(import\s+(?:type\s+)?)(\{)(.*)(\})\s*$/.exec(head);
+	if (!m) return ensureSemicolon(normalized, semicolon);
+
+	const prefix = m[1];
+	const inner = m[3];
+	const names = inner
+		.split(',')
+		.map((s) => s.trim())
+		.filter(Boolean);
+	if (names.length <= 1) return ensureSemicolon(normalized, semicolon);
+
+	const innerIndent = '\t';
+	const lines = names.map((n) => `${innerIndent}${n},`);
+	const body = `${prefix}{\n${lines.join('\n')}\n} from ${fromPart}`;
+	return ensureSemicolon(body, semicolon);
+}
+
+function sortKey(spec: string): string {
+	if (spec.startsWith('@')) return spec.slice(1);
+	return spec;
+}
+
+function compareSpec(a: string, b: string): number {
+	return sortKey(a).localeCompare(sortKey(b), 'en');
+}
+
+function stripKnownSectionComments(text: string): string {
+	let s = text;
+	s = s.replace(/\n\s*\/\*\*\s*\n\s*\*\s*Routes\s*\n\s*\*\/\s*\n/g, '\n');
+	s = s.replace(/\n\s*\/\*\*\s*\n\s*\*\s*Module\s*\n\s*\*\/\s*\n/g, '\n');
+	return s;
+}
+
+function removeLeadingSectionJSDocOnStatements(text: string): string {
+	const sf = ts.createSourceFile('x.ts', text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const toRemove: [number, number][] = [];
+
+	for (const stmt of sf.statements) {
+		const ranges = ts.getLeadingCommentRanges(text, stmt.getFullStart());
+		if (!ranges?.length) continue;
+		for (const r of ranges) {
+			const ctext = text.slice(r.pos, r.end);
+			if (!/^\s*\/\*\*/.test(ctext)) continue;
+			const inner = ctext
+				.replace(/^\s*\/\*\*\s*/, '')
+				.replace(/\s*\*\/\s*$/, '')
+				.replace(/^\s*\*\s?/gm, '')
+				.trim();
+			const lines = inner.split(/\n/).map((l) => l.trim()).filter(Boolean);
+			if (lines.length === 1 && /^(Routes|Module|Imports)$/.test(lines[0])) {
+				toRemove.push([r.pos, r.end]);
+			}
+		}
+	}
+
+	toRemove.sort((a, b) => b[0] - a[0]);
+	let out = text;
+	for (const [pos, end] of toRemove) {
+		out = out.slice(0, pos) + out.slice(end);
+	}
+	return out;
+}
+
+function organizeImports(sourceText: string, filePath: string): string {
+	const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+
+	let i = 0;
+	const stmts = sf.statements;
+	while (i < stmts.length && ts.isImportDeclaration(stmts[i])) i++;
+
+	if (i === 0) {
+		return stripKnownSectionComments(sourceText);
+	}
+
+	const importNodes = stmts.slice(0, i);
+	const replaceStart = importNodes[0].getFullStart();
+	const replaceEnd = importNodes[importNodes.length - 1].end;
+
+	const importTexts = importNodes.map((node) => sourceText.slice(node.getStart(sf), node.end).trim());
+
+	const semicolon = fileUsesSemicolon(sourceText, importTexts);
+
+	const parsed: ParsedImport[] = importTexts.map((trimmed) => {
+		const spec = getModuleSpecifier(trimmed);
+		const group = classify(spec);
+		const wrapped = wrapImportIfNeeded(trimmed, 100, semicolon);
+		return { spec, group, finalText: wrapped, multi: isMultiLineImport(wrapped) };
+	});
+
+	parsed.sort((a, b) => {
+		const go = groupOrder(a.group) - groupOrder(b.group);
+		if (go !== 0) return go;
+		const cmp = compareSpec(a.spec, b.spec);
+		if (cmp !== 0) return cmp;
+		if (a.multi !== b.multi) return a.multi ? 1 : -1;
+		return a.finalText.localeCompare(b.finalText);
+	});
+
+	const newBlock = parsed.map((p) => p.finalText).join('\n');
+	const before = sourceText.slice(0, replaceStart);
+	const after = sourceText.slice(replaceEnd);
+
+	let result = before + newBlock + after;
+	result = stripKnownSectionComments(result);
+	return result;
+}
+
+let changed = 0;
+const files = walkTsFiles(SRC);
+
+for (const filePath of files) {
+	let text = fs.readFileSync(filePath, 'utf8');
+	const original = text;
+
+	text = organizeImports(text, filePath);
+	text = removeLeadingSectionJSDocOnStatements(text);
+	text = text.replace(/\n{3,}(\/\*\*)/g, '\n\n$1');
+
+	if (text !== original) {
+		fs.writeFileSync(filePath, text, 'utf8');
+		changed++;
+	}
+}
+
+console.log('Updated ' + changed.toString() + ' / ' + files.length.toString() + ' files.');

package/src/tinify/tinyify-inject-cert.ts

@@ -0,0 +1,41 @@
+import fs from 'fs';
+
+// Check if node_modules exists
+if (!fs.existsSync('node_modules')) {
+    console.error('node_modules does not exist');
+    process.exit(1);
+}
+
+// Check if tinify dependency exists
+if (!fs.existsSync('node_modules/tinify')) {
+    console.error('tinify does not exist');
+    process.exit(1);
+}
+
+// Check if tinify/lib/data/cacert.pem exists
+const certPath = 'node_modules/tinify/lib/data/cacert.pem';
+if (!fs.existsSync(certPath)) {
+    console.error('cacert.pem does not exist');
+    process.exit(1);
+}
+
+// Check if tinify/lib/tinify/Client.js exists
+const clientPath = 'node_modules/tinify/lib/tinify/Client.js';
+if (!fs.existsSync(clientPath)) {
+    console.error('Client.js does not exist');
+    process.exit(1);
+}
+
+// Load cacert.pem into a string value
+const certData = fs.readFileSync(certPath, 'utf8');
+
+// Replace the line: const data = fs.readFileSync(`${__dirname}/../data/cacert.pem`).toString();
+// with the cacert.pem string value
+let clientData = fs.readFileSync(clientPath, 'utf8');
+clientData = clientData.replace(/const data = fs\.readFileSync\(`\$\{__dirname\}\/\.\.\/data\/cacert\.pem`\)\.toString\(\);/g, `const data = \`${certData}\`;`);
+
+// Save the file
+fs.writeFileSync(clientPath, clientData);
+
+// Log success
+console.log('Tinify transformed successfully! cacert.pem injected into Client.js');

package/dist/__vite-browser-external-BYRIRx8p.js

@@ -1,8 +0,0 @@
-const e = {}, t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  default: e
-}, Symbol.toStringTag, { value: "Module" }));
-export {
-  t as _,
-  e as f
-};

package/dist/eslint.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import('eslint/config').Config[];
-export default _default;