prettier-plugin-sort 0.0.3 → 0.1.0

package/dist/index.js

@@ -27,26 +27,24 @@ var VALID_TYPE_STYLES = new Set([
   "inline-last",
   "mixed"
 ]);
-var isValidImportGroup = (g) => typeof g === "string" && VALID_IMPORT_GROUPS.has(g);
-var isValidTypeStyle = (s) => typeof s === "string" && VALID_TYPE_STYLES.has(s);
+var isValidImportGroup = (value) => typeof value === "string" && VALID_IMPORT_GROUPS.has(value);
+var isValidTypeStyle = (value) => typeof value === "string" && VALID_TYPE_STYLES.has(value);
+function resolveBoolean(rawOptions, key) {
+  const raw = rawOptions[key];
+  return typeof raw === "boolean" ? raw : DEFAULT_SORT_OPTIONS[key];
+}
 function resolveSortOptions(rawOptions) {
   const groups = Array.isArray(rawOptions.importOrderGroups) ? rawOptions.importOrderGroups.filter(isValidImportGroup) : [];
-  const excludeKeys = Array.isArray(rawOptions.packageJsonOrderExcludeKeys) ? rawOptions.packageJsonOrderExcludeKeys.filter((k) => typeof k === "string") : [];
-  const importOrder = typeof rawOptions.importOrder === "boolean" ? rawOptions.importOrder : DEFAULT_SORT_OPTIONS.importOrder;
-  const importOrderGroups = groups.length > 0 ? groups : [...DEFAULT_SORT_OPTIONS.importOrderGroups];
-  const importOrderSeparation = typeof rawOptions.importOrderSeparation === "boolean" ? rawOptions.importOrderSeparation : DEFAULT_SORT_OPTIONS.importOrderSeparation;
+  const excludeKeys = Array.isArray(rawOptions.packageJsonOrderExcludeKeys) ? rawOptions.packageJsonOrderExcludeKeys.filter((key) => typeof key === "string") : [];
   const importOrderTypeImports = isValidTypeStyle(rawOptions.importOrderTypeImports) ? rawOptions.importOrderTypeImports : DEFAULT_SORT_OPTIONS.importOrderTypeImports;
-  const importOrderMergeDuplicates = typeof rawOptions.importOrderMergeDuplicates === "boolean" ? rawOptions.importOrderMergeDuplicates : DEFAULT_SORT_OPTIONS.importOrderMergeDuplicates;
-  const exportOrder = typeof rawOptions.exportOrder === "boolean" ? rawOptions.exportOrder : DEFAULT_SORT_OPTIONS.exportOrder;
-  const packageJsonOrder = typeof rawOptions.packageJsonOrder === "boolean" ? rawOptions.packageJsonOrder : DEFAULT_SORT_OPTIONS.packageJsonOrder;
   return {
-    importOrder,
-    importOrderGroups,
-    importOrderSeparation,
+    importOrder: resolveBoolean(rawOptions, "importOrder"),
+    importOrderGroups: groups.length > 0 ? groups : [...DEFAULT_SORT_OPTIONS.importOrderGroups],
+    importOrderSeparation: resolveBoolean(rawOptions, "importOrderSeparation"),
     importOrderTypeImports,
-    importOrderMergeDuplicates,
-    exportOrder,
-    packageJsonOrder,
+    importOrderMergeDuplicates: resolveBoolean(rawOptions, "importOrderMergeDuplicates"),
+    exportOrder: resolveBoolean(rawOptions, "exportOrder"),
+    packageJsonOrder: resolveBoolean(rawOptions, "packageJsonOrder"),
     packageJsonOrderExcludeKeys: excludeKeys
   };
 }
@@ -123,26 +121,26 @@ var options = {
 
 // src/utils.ts
 function splitTopLevel(input, separator) {
-  const out = [];
-  let buf = "";
+  const segments = [];
+  let current = "";
   let depth = 0;
-  for (const ch of input) {
-    if (ch === "{" || ch === "(" || ch === "[") {
+  for (const char of input) {
+    if (char === "{" || char === "(" || char === "[") {
       depth++;
-    } else if (ch === "}" || ch === ")" || ch === "]") {
+    } else if (char === "}" || char === ")" || char === "]") {
       depth--;
     }
-    if (ch === separator && depth === 0) {
-      out.push(buf);
-      buf = "";
+    if (char === separator && depth === 0) {
+      segments.push(current);
+      current = "";
       continue;
     }
-    buf += ch;
+    current += char;
   }
-  if (buf.length > 0) {
-    out.push(buf);
+  if (current.length > 0) {
+    segments.push(current);
   }
-  return out.map((s) => s.trim()).filter((s) => s.length > 0);
+  return segments.map((segment) => segment.trim()).filter((segment) => segment.length > 0);
 }
 
 // src/sort-exports.ts
@@ -159,8 +157,8 @@ function sortExports(text, rawOptions) {
     const sorted = [...members].sort((a, b) => stripTypePrefix(a).localeCompare(stripTypePrefix(b), "en", {
       sensitivity: "base"
     }));
-    const same = sorted.every((m, i) => m === members[i]);
-    if (same) {
+    const unchanged = sorted.every((member, index) => member === members[index]);
+    if (unchanged) {
       return match;
     }
     const prefix = typeKeyword ? `export${typeKeyword}` : "export";
@@ -197,20 +195,19 @@ function detectGroup(source) {
   }
   return "external";
 }
+var TYPE_PREFIX = /^type\s+(.+)$/s;
 function splitMembers(inner) {
   return splitTopLevel(inner, ",").map((part) => {
-    const isType = /^type\s+/.test(part);
-    const name = isType ? part.replace(/^type\s+/, "").trim() : part;
-    return { name, isType };
+    const match = TYPE_PREFIX.exec(part);
+    return match ? { name: match[1].trim(), isType: true } : { name: part, isType: false };
   });
 }
-function parseImport(stmt) {
-  const trimmed = stmt.raw.trim();
-  const leadingComments = stmt.leadingComments;
+function parseImport(statement) {
+  const trimmed = statement.raw.trim();
+  const leadingComments = statement.leadingComments;
   const sideEffect = /^import\s*(['"])([^'"]+)\1(?:\s+with\s*(\{[^}]*\}))?\s*;?$/.exec(trimmed);
   if (sideEffect) {
     return {
-      raw: trimmed,
       source: sideEffect[2] ?? "",
       typeClause: false,
       sideEffect: true,
@@ -221,14 +218,14 @@ function parseImport(stmt) {
       leadingComments
     };
   }
-  const m = /^import\s+(type\s+)?([\s\S]+?)\s*from\s*(['"])([^'"]+)\3(?:\s+with\s*(\{[^}]*\}))?\s*;?$/.exec(trimmed);
-  if (!m) {
+  const match = /^import\s+(type\s+)?([\s\S]+?)\s*from\s*(['"])([^'"]+)\3(?:\s+with\s*(\{[^}]*\}))?\s*;?$/.exec(trimmed);
+  if (!match) {
     return null;
   }
-  const typeClause = Boolean(m[1]);
-  const clause = (m[2] ?? "").trim();
-  const source = m[4] ?? "";
-  const attributes = m[5] ?? null;
+  const typeClause = Boolean(match[1]);
+  const clause = (match[2] ?? "").trim();
+  const source = match[4] ?? "";
+  const attributes = match[5] ?? null;
   let defaultSpec = null;
   let namespaceSpec = null;
   let members = null;
@@ -243,7 +240,6 @@ function parseImport(stmt) {
     }
   }
   return {
-    raw: trimmed,
     source,
     typeClause,
     sideEffect: false,
@@ -263,17 +259,21 @@ function extractImportBlock(text) {
   const start = first.index + (text[first.index] === `
 ` ? 1 : 0);
   const statements = [];
+  const skipRe = /(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)?[ \t]*\n)*/y;
+  const importRe = /[ \t]*(import\b[\s\S]*?(?:from\s*(['"])[^'"]+\2|(['"])[^'"]+\3)(?:\s+with\s*\{[^}]*\})?\s*;?)/y;
   let cursor = start;
   while (cursor < text.length) {
-    const chunkMatch = /^(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)?[ \t]*\n)*/.exec(text.slice(cursor));
-    const chunk = chunkMatch ? chunkMatch[0] : "";
-    const afterSkip = cursor + chunk.length;
-    const importMatch = /^[ \t]*(import\b[\s\S]*?(?:from\s*(['"])[^'"]+\2|(['"])[^'"]+\3)(?:\s+with\s*\{[^}]*\})?\s*;?)/.exec(text.slice(afterSkip));
+    skipRe.lastIndex = cursor;
+    const skipMatch = skipRe.exec(text);
+    const skipped = skipMatch ? skipMatch[0] : "";
+    const afterSkip = cursor + skipped.length;
+    importRe.lastIndex = afterSkip;
+    const importMatch = importRe.exec(text);
     if (!importMatch) {
       break;
     }
-    const normalised = chunk.endsWith(`
-`) ? chunk.slice(0, -1) : chunk;
+    const normalised = skipped.endsWith(`
+`) ? skipped.slice(0, -1) : skipped;
     const commentLines = normalised.length > 0 ? normalised.split(`
 `) : [];
     const leadingLines = [];
@@ -305,28 +305,23 @@ function extractImportBlock(text) {
 function renderMembers(members) {
   return members.map((member) => member.isType ? `type ${member.name}` : member.name).join(", ");
 }
+function renderSpecifiers(importDecl) {
+  const parts = [];
+  if (importDecl.defaultSpec) {
+    parts.push(importDecl.defaultSpec);
+  }
+  if (importDecl.namespaceSpec) {
+    parts.push(importDecl.namespaceSpec);
+  }
+  if (importDecl.members) {
+    parts.push(`{ ${renderMembers(importDecl.members)} }`);
+  }
+  return parts.join(", ");
+}
 function renderImport(importDecl) {
   const suffix = importDecl.attributes ? ` with ${importDecl.attributes}` : "";
-  const body = (() => {
-    if (importDecl.sideEffect) {
-      return `import '${importDecl.source}'${suffix};`;
-    }
-    if (importDecl.typeClause) {
-      const inner = importDecl.members ? `{ ${renderMembers(importDecl.members)} }` : "";
-      return `import type ${inner} from '${importDecl.source}'${suffix};`;
-    }
-    const leftParts = [];
-    if (importDecl.defaultSpec) {
-      leftParts.push(importDecl.defaultSpec);
-    }
-    if (importDecl.namespaceSpec) {
-      leftParts.push(importDecl.namespaceSpec);
-    }
-    if (importDecl.members) {
-      leftParts.push(`{ ${renderMembers(importDecl.members)} }`);
-    }
-    return `import ${leftParts.join(", ")} from '${importDecl.source}'${suffix};`;
-  })();
+  const source = `'${importDecl.source}'`;
+  const body = importDecl.sideEffect ? `import ${source}${suffix};` : importDecl.typeClause ? `import type ${renderSpecifiers(importDecl)} from ${source}${suffix};` : `import ${renderSpecifiers(importDecl)} from ${source}${suffix};`;
   return importDecl.leadingComments + body;
 }
 function sortMembersAlpha(members) {
@@ -345,9 +340,9 @@ function normalizeTypeClause(importDecl) {
 function mergeImportsFromSameSource(imports) {
   const indexBySource = new Map;
   const result = [];
-  for (const raw of imports) {
-    const importDecl = normalizeTypeClause(raw);
-    if (importDecl.sideEffect) {
+  for (const rawImport of imports) {
+    const importDecl = normalizeTypeClause(rawImport);
+    if (importDecl.sideEffect || importDecl.typeClause) {
       result.push(importDecl);
       continue;
     }
@@ -359,7 +354,6 @@ function mergeImportsFromSameSource(imports) {
     }
     const existing = result[existingIndex];
     result[existingIndex] = {
-      raw: "",
       source: existing.source,
       typeClause: false,
       sideEffect: false,
@@ -385,7 +379,6 @@ function applyTypeImports(importDecl, style) {
     const out = [];
     if (typeMembers2.length > 0) {
       out.push({
-        raw: "",
         source: importDecl.source,
         typeClause: true,
         sideEffect: false,
@@ -406,7 +399,7 @@ function applyTypeImports(importDecl, style) {
     }
     return out.length > 0 ? out : [importDecl];
   }
-  const base = importDecl.typeClause ? {
+  const inlineBase = importDecl.typeClause ? {
     ...importDecl,
     typeClause: false,
     members: importDecl.members.map((member) => ({
@@ -415,14 +408,14 @@ function applyTypeImports(importDecl, style) {
     }))
   } : { ...importDecl, members: importDecl.members };
   if (style === "mixed") {
-    return [{ ...base, members: sortMembersAlpha(base.members) }];
+    return [{ ...inlineBase, members: sortMembersAlpha(inlineBase.members) }];
   }
-  const typeMembers = base.members.filter((m) => m.isType);
-  const valueMembers = base.members.filter((m) => !m.isType);
+  const typeMembers = inlineBase.members.filter((member) => member.isType);
+  const valueMembers = inlineBase.members.filter((member) => !member.isType);
   const sortedTypes = sortMembersAlpha(typeMembers);
   const sortedValues = sortMembersAlpha(valueMembers);
   const ordered = style === "inline-first" ? [...sortedTypes, ...sortedValues] : [...sortedValues, ...sortedTypes];
-  return [{ ...base, members: ordered }];
+  return [{ ...inlineBase, members: ordered }];
 }
 function sortSegment(imports, options2, groupIndex, fallback) {
   if (imports.length === 0) {
@@ -432,7 +425,7 @@ function sortSegment(imports, options2, groupIndex, fallback) {
   const deduped = options2.importOrderMergeDuplicates ? mergeImportsFromSameSource(imports) : imports;
   const rewritten = deduped.flatMap((importDecl) => applyTypeImports(importDecl, style));
   const decorated = rewritten.map((importDecl, index) => ({
-    stmt: importDecl,
+    importDecl,
     group: detectGroup(importDecl.source),
     originalIndex: index
   }));
@@ -442,24 +435,24 @@ function sortSegment(imports, options2, groupIndex, fallback) {
     if (groupOrderA !== groupOrderB) {
       return groupOrderA - groupOrderB;
     }
-    const sourceA = a.stmt.source.toLowerCase();
-    const sourceB = b.stmt.source.toLowerCase();
+    const sourceA = a.importDecl.source.toLowerCase();
+    const sourceB = b.importDecl.source.toLowerCase();
     if (sourceA !== sourceB) {
       return sourceA < sourceB ? -1 : 1;
     }
-    if (a.stmt.typeClause !== b.stmt.typeClause) {
-      return a.stmt.typeClause ? -1 : 1;
+    if (a.importDecl.typeClause !== b.importDecl.typeClause) {
+      return a.importDecl.typeClause ? -1 : 1;
     }
     return a.originalIndex - b.originalIndex;
   });
   const lines = [];
-  let prevGroup = null;
+  let previousGroup = null;
   for (const item of decorated) {
-    if (options2.importOrderSeparation && prevGroup !== null && item.group !== prevGroup) {
+    if (options2.importOrderSeparation && previousGroup !== null && item.group !== previousGroup) {
       lines.push("");
     }
-    lines.push(renderImport(item.stmt));
-    prevGroup = item.group;
+    lines.push(renderImport(item.importDecl));
+    previousGroup = item.group;
   }
   return lines;
 }
@@ -472,7 +465,7 @@ function sortImports(text, rawOptions) {
   if (!block || block.statements.length === 0) {
     return text;
   }
-  const parsed = block.statements.map((rawStmt) => parseImport(rawStmt)).filter((decl) => decl !== null);
+  const parsed = block.statements.map((rawStatement) => parseImport(rawStatement)).filter((importDecl) => importDecl !== null);
   if (parsed.length === 0) {
     return text;
   }
@@ -485,31 +478,30 @@ function sortImports(text, rawOptions) {
   let currentSegment = [];
   for (const importDecl of parsed) {
     if (importDecl.sideEffect) {
-      chunks.push({ kind: "segment", imports: currentSegment });
-      chunks.push({ kind: "side-effect", stmt: importDecl });
-      currentSegment = [];
+      if (currentSegment.length > 0) {
+        chunks.push({ kind: "segment", imports: currentSegment });
+        currentSegment = [];
+      }
+      chunks.push({ kind: "side-effect", importDecl });
     } else {
       currentSegment.push(importDecl);
     }
   }
-  chunks.push({ kind: "segment", imports: currentSegment });
+  if (currentSegment.length > 0) {
+    chunks.push({ kind: "segment", imports: currentSegment });
+  }
   const allLines = [];
+  let previousKind = null;
   for (const chunk of chunks) {
+    if (previousKind !== null && previousKind !== chunk.kind && options2.importOrderSeparation) {
+      allLines.push("");
+    }
     if (chunk.kind === "segment") {
-      if (chunk.imports.length === 0) {
-        continue;
-      }
-      const segmentLines = sortSegment(chunk.imports, options2, groupIndex, fallback);
-      if (allLines.length > 0 && options2.importOrderSeparation) {
-        allLines.push("");
-      }
-      allLines.push(...segmentLines);
+      allLines.push(...sortSegment(chunk.imports, options2, groupIndex, fallback));
     } else {
-      if (allLines.length > 0 && options2.importOrderSeparation) {
-        allLines.push("");
-      }
-      allLines.push(renderImport(chunk.stmt));
+      allLines.push(renderImport(chunk.importDecl));
     }
+    previousKind = chunk.kind;
   }
   const replacement = allLines.join(`
 `);
@@ -666,15 +658,15 @@ function sortObjectKeysByOrder(record, order) {
       rest.push(entry);
     }
   }
-  known.sort(([left], [right]) => (orderIndex.get(left) ?? 0) - (orderIndex.get(right) ?? 0));
-  rest.sort(([left], [right]) => left.localeCompare(right, "en"));
+  known.sort(([a], [b]) => (orderIndex.get(a) ?? 0) - (orderIndex.get(b) ?? 0));
+  rest.sort(([a], [b]) => a.localeCompare(b, "en"));
   return Object.fromEntries([...known, ...rest]);
 }
 function sortObjectKeysAlpha(value) {
   if (!isPlainObject(value)) {
     return value;
   }
-  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right, "en")));
+  return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b, "en")));
 }
 function sortStringArrayAlpha(value) {
   return [...value].sort((a, b) => a.localeCompare(b, "en"));
@@ -704,7 +696,7 @@ function sortPackageJson(text, rawOptions) {
   if (!isPlainObject(parsed)) {
     return text;
   }
-  let result = { ...parsed };
+  let result = parsed;
   for (const field of DEPENDENCY_FIELDS) {
     const dependencyMap = result[field];
     if (dependencyMap !== undefined && !exclude.has(field)) {
@@ -735,8 +727,8 @@ function wrap(parser, ...transforms) {
     ...parser,
     async preprocess(text, parserOptions) {
       let source = parser.preprocess ? await parser.preprocess(text, parserOptions) : text;
-      for (const fn of transforms) {
-        source = fn(source, parserOptions);
+      for (const transform of transforms) {
+        source = transform(source, parserOptions);
       }
       return source;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sort",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "An all-in-one Prettier plugin to sort imports, package.json keys, and more.",
   "keywords": [
     "imports",