code-languages 1.42.5 → 1.43.1

package/dist/index.js

@@ -10754,7 +10754,7 @@ var init_nix = __esm({
         packageManagers: ["nix", "nix flakes"],
         ecosystems: ["Linux", "macOS", "NixOS", "DevOps"]
       },
-      version: "2.34.8",
+      version: "2.35.2",
       logo: "https://cdn.simpleicons.org/nixos/5277C3",
       color: "#5277C3",
       i18n: {
@@ -18465,6 +18465,50 @@ var init_zsh = __esm({
 });
 
 // src/domain/category/registry.ts
+var CATEGORY_REGISTRY = [
+  {
+    slug: "frontend",
+    name: "Frontend",
+    description: "Languages that target the browser only.",
+    aliases: ["frontend", "front-end"]
+  },
+  {
+    slug: "backend",
+    name: "Backend",
+    description: "Languages that run on a server runtime.",
+    aliases: ["backend", "back-end", "server"]
+  },
+  {
+    slug: "fullstack",
+    name: "Fullstack",
+    description: "Languages that target both the browser and a server runtime.",
+    aliases: ["fullstack", "full-stack"]
+  },
+  {
+    slug: "systems",
+    name: "Systems",
+    description: "Low-level, native, and embedded programming languages.",
+    aliases: ["systems", "systems-programming", "low-level"]
+  },
+  {
+    slug: "data-science",
+    name: "Data Science",
+    description: "Languages for data analysis, machine learning, and scientific computing.",
+    aliases: ["data-science", "datascience", "data"]
+  },
+  {
+    slug: "scripting",
+    name: "Scripting",
+    description: "Shell and scripting languages.",
+    aliases: ["scripting", "shell"]
+  },
+  {
+    slug: "other",
+    name: "Other",
+    description: "Languages that do not match any other category.",
+    aliases: ["other"]
+  }
+];
 var BROWSER_TARGETS = ["Browser"];
 var SERVER_TARGETS = [
   "Node.js",
@@ -18534,8 +18578,20 @@ function matchesCategory(lang, category) {
       return !browser && !server && !poolMatches(pool, SYSTEMS_TARGETS) && !poolMatches(pool, DATA_TARGETS) && !poolMatches(pool, SCRIPT_TARGETS);
   }
 }
+function findCategory(value) {
+  const key = value.trim().toLowerCase();
+  return CATEGORY_REGISTRY.find((c2) => c2.aliases.includes(key));
+}
+function categoryInfoFromDefinition(def) {
+  return {
+    slug: def.slug,
+    name: def.name,
+    description: def.description,
+    aliases: def.aliases
+  };
+}
 function getCategories() {
-  return ["frontend", "backend", "fullstack", "systems", "data-science", "scripting", "other"];
+  return CATEGORY_REGISTRY.map((c2) => c2.slug);
 }
 
 // src/domain/detection/match.ts
@@ -20486,6 +20542,14 @@ function packageManagerInfoFromDefinition(def) {
     aliases: def.aliases
   };
 }
+function packageManagersForRuntime(names) {
+  const keys = names.map((name) => name.trim().toLowerCase());
+  return PACKAGE_MANAGER_REGISTRY.filter(
+    (pm) => keys.some(
+      (key) => pm.name.toLowerCase() === key || pm.aliases.includes(key) || pm.targets.some((target) => target.toLowerCase() === key)
+    )
+  ).map(packageManagerInfoFromDefinition);
+}
 function getPackageManagers() {
   return PACKAGE_MANAGER_REGISTRY.map(packageManagerInfoFromDefinition);
 }
@@ -21163,13 +21227,93 @@ var createLanguageRequest = (getLanguage, loadLanguageModule) => {
   };
   return request;
 };
+var getLanguageBySlug = (slug) => languageMap.get(slug);
+var getRelationSlugs = (language) => {
+  const { supersetOf = [], dialectOf = [], compilesTo = [] } = language.relations ?? {};
+  return [...supersetOf, ...dialectOf, ...compilesTo];
+};
+var categoryPredicate = (value) => {
+  const resolvedCategory = findCategory(value)?.slug ?? value;
+  return (language) => matchesCategory(language, resolvedCategory);
+};
+var paradigmPredicate = (value) => {
+  const targets = findParadigm(value)?.targets ?? [value];
+  return (language) => matchesParadigm(language, targets);
+};
+var runtimePredicate = (value) => {
+  const targets = findRuntime(value)?.targets ?? [value];
+  return (language) => matchesRuntime(language, targets);
+};
+var packageManagerPredicate = (value) => {
+  const targets = findPackageManager(value)?.targets ?? [value];
+  return (language) => matchesPackageManager(language, targets);
+};
+var ecosystemPredicate = (value) => {
+  const targets = findEcosystem(value)?.targets ?? [value];
+  return (language) => matchesEcosystem(language, targets);
+};
+var extensionPredicate = (value) => {
+  const normalized = value.trim().toLowerCase();
+  return (language) => language.extensions.some((extension) => {
+    const normalizedExtension = extension.toLowerCase();
+    return normalizedExtension === normalized || normalizedExtension === `.${normalized}`;
+  });
+};
+var statusPredicate = (value) => (language) => (language.status ?? "active") === value;
+var relatedPredicate = (slug) => {
+  const resolvedSlug = resolveLanguageLookup(slug);
+  const source = getLanguageBySlug(resolvedSlug);
+  const outgoing = new Set(source ? getRelationSlugs(source) : []);
+  return (language) => language.slug !== resolvedSlug && (outgoing.has(language.slug) || getRelationSlugs(language).includes(resolvedSlug));
+};
 var createLanguageCollectionRequest = (getLanguageList, loadLanguageList) => {
   let requestedLocale = defaultLocale;
+  const narrow = (predicate) => {
+    const filtered = () => getLanguageList().filter(predicate);
+    const next = createLanguageCollectionRequest(filtered, async () => {
+      const loaded = await Promise.all(filtered().map((language) => loadLanguage(language.slug)));
+      return loaded.filter((language) => Boolean(language));
+    });
+    return next.locale(requestedLocale);
+  };
   const request = {
     locale(locale) {
       requestedLocale = locale;
       return request;
     },
+    category(value) {
+      return narrow(categoryPredicate(value));
+    },
+    paradigm(value) {
+      return narrow(paradigmPredicate(value));
+    },
+    runtime(value) {
+      return narrow(runtimePredicate(value));
+    },
+    packageManager(value) {
+      return narrow(packageManagerPredicate(value));
+    },
+    ecosystem(value) {
+      return narrow(ecosystemPredicate(value));
+    },
+    extension(value) {
+      return narrow(extensionPredicate(value));
+    },
+    status(value) {
+      return narrow(statusPredicate(value));
+    },
+    related(slug) {
+      return narrow(relatedPredicate(slug));
+    },
+    slugs() {
+      return getLanguageList().map((language) => language.slug);
+    },
+    count() {
+      return getLanguageList().length;
+    },
+    first() {
+      return localizeOptionalLanguage(getLanguageList().at(0), requestedLocale);
+    },
     get() {
       return getLanguageList().map((language) => localizeLanguage(language, requestedLocale));
     },
@@ -21187,17 +21331,20 @@ var createFilteredLanguageCollection = (predicate) => {
     return loaded.filter((language) => Boolean(language));
   });
 };
+var createGroupSelection = (definition, toInfo, predicate) => ({
+  info() {
+    return definition ? toInfo(definition) : void 0;
+  },
+  langs() {
+    return createFilteredLanguageCollection(predicate);
+  }
+});
 var loadDetectedLanguages = async (filename) => {
   const detectedLanguages = await Promise.all(
     detectLanguageSlugs(filename).map((slug) => loadLanguage(slug))
   );
   return detectedLanguages.filter((language) => Boolean(language));
 };
-var getLanguageBySlug = (slug) => languageMap.get(slug);
-var getRelationSlugs = (language) => {
-  const { supersetOf = [], dialectOf = [], compilesTo = [] } = language.relations ?? {};
-  return [...supersetOf, ...dialectOf, ...compilesTo];
-};
 var getDetectedLanguages = (filename) => detectLanguageSlugs(filename).map((slug) => getLanguageBySlug(slug)).filter((language) => Boolean(language));
 var api = {
   /**
@@ -21261,15 +21408,9 @@ var api = {
    * api.extension('ts').langs().locale('es').get();
    */
   extension(value) {
-    const normalized = value.trim().toLowerCase();
     return {
       langs() {
-        return createFilteredLanguageCollection(
-          (language) => language.extensions.some((extension) => {
-            const normalizedExtension = extension.toLowerCase();
-            return normalizedExtension === normalized || normalizedExtension === `.${normalized}`;
-          })
-        );
+        return createFilteredLanguageCollection(extensionPredicate(value));
       }
     };
   },
@@ -21325,9 +21466,7 @@ var api = {
   status(value) {
     return {
       langs() {
-        return createFilteredLanguageCollection(
-          (language) => (language.status ?? "active") === value
-        );
+        return createFilteredLanguageCollection(statusPredicate(value));
       }
     };
   },
@@ -21340,14 +21479,9 @@ var api = {
    * api.related('typescript').langs().get(); // JavaScript
    */
   related(slug) {
-    const resolvedSlug = resolveLanguageLookup(slug);
     return {
       langs() {
-        const source = getLanguageBySlug(resolvedSlug);
-        const outgoing = new Set(source ? getRelationSlugs(source) : []);
-        return createFilteredLanguageCollection(
-          (language) => language.slug !== resolvedSlug && (outgoing.has(language.slug) || getRelationSlugs(language).includes(resolvedSlug))
-        );
+        return createFilteredLanguageCollection(relatedPredicate(slug));
       }
     };
   },
@@ -21360,16 +21494,14 @@ var api = {
    * @example
    * api.runtime('node').langs().locale('es').get();
    * api.runtime('.net').info();
+   * api.runtime('node').packageManagers();
    */
   runtime(value) {
     const definition = findRuntime(value);
-    const targets = definition?.targets ?? [value];
     return {
-      info() {
-        return definition ? runtimeInfoFromDefinition(definition) : void 0;
-      },
-      langs() {
-        return createFilteredLanguageCollection((language) => matchesRuntime(language, targets));
+      ...createGroupSelection(definition, runtimeInfoFromDefinition, runtimePredicate(value)),
+      packageManagers() {
+        return definition ? packageManagersForRuntime(definition.packageManagers) : [];
       }
     };
   },
@@ -21387,14 +21519,11 @@ var api = {
     const definition = findPackageManager(value);
     const targets = definition?.targets ?? [value];
     return {
-      info() {
-        return definition ? packageManagerInfoFromDefinition(definition) : void 0;
-      },
-      langs() {
-        return createFilteredLanguageCollection(
-          (language) => matchesPackageManager(language, targets)
-        );
-      },
+      ...createGroupSelection(
+        definition,
+        packageManagerInfoFromDefinition,
+        packageManagerPredicate(value)
+      ),
       runtimes() {
         return runtimesForPackageManager(targets);
       }
@@ -21416,14 +21545,15 @@ var api = {
    *
    * @example
    * api.category('backend').langs().locale('es').get();
+   * api.category('backend').info();
    * await api.category('data-science').langs().load();
    */
   category(value) {
-    return {
-      langs() {
-        return createFilteredLanguageCollection((language) => matchesCategory(language, value));
-      }
-    };
+    return createGroupSelection(
+      findCategory(value),
+      categoryInfoFromDefinition,
+      categoryPredicate(value)
+    );
   },
   /**
    * Selects every language that uses the given programming paradigm.
@@ -21436,16 +21566,11 @@ var api = {
    * api.paradigm('oop').info();
    */
   paradigm(value) {
-    const definition = findParadigm(value);
-    const targets = definition?.targets ?? [value];
-    return {
-      info() {
-        return definition ? paradigmInfoFromDefinition(definition) : void 0;
-      },
-      langs() {
-        return createFilteredLanguageCollection((language) => matchesParadigm(language, targets));
-      }
-    };
+    return createGroupSelection(
+      findParadigm(value),
+      paradigmInfoFromDefinition,
+      paradigmPredicate(value)
+    );
   },
   /**
    * Selects every language that belongs to the given ecosystem.
@@ -21458,16 +21583,11 @@ var api = {
    * api.ecosystem('blockchain').info();
    */
   ecosystem(value) {
-    const definition = findEcosystem(value);
-    const targets = definition?.targets ?? [value];
-    return {
-      info() {
-        return definition ? ecosystemInfoFromDefinition(definition) : void 0;
-      },
-      langs() {
-        return createFilteredLanguageCollection((language) => matchesEcosystem(language, targets));
-      }
-    };
+    return createGroupSelection(
+      findEcosystem(value),
+      ecosystemInfoFromDefinition,
+      ecosystemPredicate(value)
+    );
   },
   /**
    * Detects every matching language for a filename or path.

package/dist/languages/nix.cjs

@@ -13,7 +13,7 @@ var nix = {
     packageManagers: ["nix", "nix flakes"],
     ecosystems: ["Linux", "macOS", "NixOS", "DevOps"]
   },
-  version: "2.34.8",
+  version: "2.35.2",
   logo: "https://cdn.simpleicons.org/nixos/5277C3",
   color: "#5277C3",
   i18n: {

package/dist/languages/nix.js

@@ -11,7 +11,7 @@ var nix = {
     packageManagers: ["nix", "nix flakes"],
     ecosystems: ["Linux", "macOS", "NixOS", "DevOps"]
   },
-  version: "2.34.8",
+  version: "2.35.2",
   logo: "https://cdn.simpleicons.org/nixos/5277C3",
   color: "#5277C3",
   i18n: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-languages",
-  "version": "1.42.5",
+  "version": "1.43.1",
   "description": "Structured metadata for programming languages.",
   "homepage": "https://github.com/ElJijuna/code-languages#readme",
   "bugs": {