slug-lib-js 0.0.0-stage → 2.1.3

package/assets/site/site.js

@@ -0,0 +1,196 @@
+/* slug-lib-js site bundle — docs demo with bundled helpers */
+(function () {
+  "use strict";
+
+  var DEFAULT_SEP = "-";
+
+  function slugify(str, opts) {
+    opts = opts || {};
+    if (str == null) return "";
+    var separator = opts.separator || DEFAULT_SEP;
+    var lower = opts.lower !== false;
+    var strict = !!opts.strict;
+    var trim = opts.trim !== false;
+    var s = String(str).normalize("NFKD").replace(/[̀-ͯ]/g, "");
+    s = s.replace(/[^a-zA-Z0-9]+/g, separator);
+    if (lower) s = s.toLowerCase();
+    if (strict) s = s.replace(/[^a-z0-9]/g, "");
+    if (trim) s = s.replace(new RegExp("^" + separator + "+|" + separator + "+$", "g"), "");
+    return s;
+  }
+
+  function deslugify(slug, opts) {
+    opts = opts || {};
+    if (slug == null) return "";
+    var separator = opts.separator || DEFAULT_SEP;
+    var capitalize = !!opts.capitalize;
+    var words = String(slug).split(new RegExp(separator + "+")).filter(Boolean);
+    if (capitalize) {
+      words = words.map(function (w) { return w[0].toUpperCase() + w.slice(1); });
+    }
+    return words.join(" ");
+  }
+
+  function isSlug(str, opts) {
+    opts = opts || {};
+    if (typeof str !== "string" || !str) return false;
+    var separator = opts.separator || DEFAULT_SEP;
+    var allowUpper = !!opts.allowUpper;
+    var esc = separator.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp("^[a-z0-9" + (allowUpper ? "A-Z" : "") + "]+(" + esc + "[a-z0-9" + (allowUpper ? "A-Z" : "") + "]+)*$").test(str);
+  }
+
+  function uniqueSlug(base, taken) {
+    taken = taken || [];
+    var used = {};
+    taken.forEach(function (t) { used[String(t)] = true; });
+    var root = slugify(base) || "item";
+    if (!used[root]) return root;
+    var i = 2;
+    while (used[root + "-" + i]) i++;
+    return root + "-" + i;
+  }
+
+  function slugWords(slug, opts) {
+    return deslugify(slug, opts).split(" ").filter(Boolean);
+  }
+
+  function slugLength(slug) {
+    return String(slug || "").length;
+  }
+
+  function truncateSlug(slug, max, opts) {
+    opts = opts || {};
+    var s = String(slug || "");
+    if (s.length <= max) return s;
+    var sep = opts.separator || DEFAULT_SEP;
+    var cut = s.slice(0, max).replace(new RegExp(sep + "[^" + sep + "]*$"), "");
+    return cut || s.slice(0, max);
+  }
+
+  function randomSlug(len, alphabet) {
+    len = len || 8;
+    var chars = alphabet || "abcdefghijklmnopqrstuvwxyz0123456789";
+    var buf = new Uint8Array(len);
+    crypto.getRandomValues(buf);
+    var out = "";
+    for (var i = 0; i < len; i++) out += chars[buf[i] % chars.length];
+    return out;
+  }
+
+  var API = [
+    ["slugify", "slugify(str, opts?)", "Normalize + transliterate to a slug.", "core"],
+    ["deslugify", "deslugify(slug, opts?)", "Split a slug back into words.", "core"],
+    ["isSlug", "isSlug(str, opts?)", "Validate slug shape.", "core"],
+    ["uniqueSlug", "uniqueSlug(base, taken?)", "First free -2, -3, ... variant.", "core"],
+    ["slugWords", "slugWords(slug, opts?)", "Slug as a word array.", "inspect"],
+    ["slugLength", "slugLength(slug)", "Character count.", "inspect"],
+    ["truncateSlug", "truncateSlug(slug, max)", "Cut on a separator boundary.", "inspect"],
+    ["randomSlug", "randomSlug(len?, alphabet?)", "Crypto-random slug.", "generate"],
+  ];
+
+  var GROUP_LABEL = { core: "core", inspect: "inspect", generate: "generate" };
+
+  function esc(s) {
+    return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+
+  function mount() {
+    var tbody = document.getElementById("api-rows");
+    if (tbody) {
+      var lastGroup = null;
+      API.forEach(function (row) {
+        if (GROUP_LABEL[row[3]] !== lastGroup) {
+          lastGroup = GROUP_LABEL[row[3]];
+          var h = document.createElement("tr");
+          var hc = document.createElement("td");
+          hc.colSpan = 3;
+          hc.className = "group";
+          hc.textContent = lastGroup;
+          h.appendChild(hc);
+          tbody.appendChild(h);
+        }
+        var tr = document.createElement("tr");
+        tr.innerHTML =
+          '<td class="name">' + esc(row[0]) + "</td>" +
+          '<td class="sig">' + esc(row[1]) + "</td>" +
+          '<td class="what">' + esc(row[2]) + "</td>";
+        tbody.appendChild(tr);
+      });
+    }
+
+    var set = function (id, text) {
+      var el = document.getElementById(id);
+      if (el) el.textContent = text;
+    };
+
+    set(
+      "demo-cn",
+      'slugify("Hello World!")\n' +
+        "=> \"" + slugify("Hello World!") + "\"\n" +
+        'slugify("Café Über Alles")\n' +
+        "=> \"" + slugify("Café Über Alles") + "\""
+    );
+
+    set(
+      "demo-fmt",
+      'deslugify("my-first-post")\n' +
+        "=> \"" + deslugify("my-first-post") + "\"\n" +
+        'isSlug("my-post-2")       => ' + isSlug("my-post-2") + "\n" +
+        'isSlug("My Post")        => ' + isSlug("My Post")
+    );
+
+    set(
+      "demo-time",
+      'uniqueSlug("My Post", taken)\n' +
+        'taken = ["my-post", "my-post-2"]\n' +
+        "=> \"" + uniqueSlug("My Post", ["my-post", "my-post-2"]) + "\"\n" +
+        'randomSlug(8)             => "' + randomSlug(8) + '"'
+    );
+
+    set(
+      "demo-deb",
+      'truncateSlug("a-very-long-post-title-here", 20)\n' +
+        "=> \"" + truncateSlug("a-very-long-post-title-here", 20) + "\"\n" +
+        'slugWords("hello-brave-new-world")\n' +
+        "=> " + JSON.stringify(slugWords("hello-brave-new-world"))
+    );
+
+    var btn = document.getElementById("copy-install");
+    if (btn) {
+      btn.addEventListener("click", function () {
+        var text = "npm install slug-lib-js";
+        var done = function () {
+          btn.textContent = "copied";
+          btn.classList.add("done");
+          setTimeout(function () {
+            btn.textContent = "copy";
+            btn.classList.remove("done");
+          }, 1400);
+        };
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+          navigator.clipboard.writeText(text).then(done, fallback);
+        } else {
+          fallback();
+        }
+        function fallback() {
+          var ta = document.createElement("textarea");
+          ta.value = text;
+          ta.style.position = "fixed";
+          ta.style.opacity = "0";
+          document.body.appendChild(ta);
+          ta.select();
+          try { document.execCommand("copy"); } catch (e) {}
+          document.body.removeChild(ta);
+          done();
+        }
+      });
+    }
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", mount);
+  } else {
+    mount();
+  }
+})();

package/index.cjs

@@ -0,0 +1,69 @@
+"use strict";
+
+const DEFAULT_SEP = "-";
+
+function slugify(str, opts = {}) {
+  if (str == null) return "";
+  const { separator = DEFAULT_SEP, lower = true, strict = false, trim = true } = opts;
+  let s = String(str).normalize("NFKD").replace(/[̀-ͯ]/g, "");
+  s = s.replace(/[^a-zA-Z0-9]+/g, separator);
+  if (lower) s = s.toLowerCase();
+  if (strict) s = s.replace(new RegExp(`[^a-z0-9]`, "g"), "");
+  if (trim) s = s.replace(new RegExp(`^${separator}+|${separator}+$`, "g"), "");
+  return s;
+}
+
+function deslugify(slug, opts = {}) {
+  if (slug == null) return "";
+  const { separator = DEFAULT_SEP, capitalize = false } = opts;
+  let words = String(slug).split(new RegExp(`${separator}+`)).filter(Boolean);
+  if (capitalize) words = words.map((w) => w[0].toUpperCase() + w.slice(1));
+  return words.join(" ");
+}
+
+function isSlug(str, opts = {}) {
+  if (typeof str !== "string" || !str) return false;
+  const { separator = DEFAULT_SEP, allowUpper = false } = opts;
+  const esc = separator.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^[a-z0-9${allowUpper ? "A-Z" : ""}]+(${esc}[a-z0-9${allowUpper ? "A-Z" : ""}]+)*$`).test(str);
+}
+
+function uniqueSlug(base, taken = []) {
+  const used = new Set(taken.map((t) => String(t)));
+  const root = slugify(base) || "item";
+  if (!used.has(root)) return root;
+  let i = 2;
+  while (used.has(`${root}-${i}`)) i++;
+  return `${root}-${i}`;
+}
+
+function slugWords(slug, opts = {}) {
+  return deslugify(slug, opts).split(" ").filter(Boolean);
+}
+
+function slugLength(slug) {
+  return String(slug || "").length;
+}
+
+function truncateSlug(slug, max, opts = {}) {
+  const s = String(slug || "");
+  if (s.length <= max) return s;
+  const sep = opts.separator || DEFAULT_SEP;
+  const cut = s.slice(0, max).replace(new RegExp(`${sep}[^${sep}]*$`), "");
+  return cut || s.slice(0, max);
+}
+
+function randomSlug(len = 8, alphabet) {
+  const chars = alphabet || "abcdefghijklmnopqrstuvwxyz0123456789";
+  const buf = new Uint8Array(len);
+  const c = (globalThis.crypto || require("crypto").webcrypto);
+  c.getRandomValues(buf);
+  let out = "";
+  for (let i = 0; i < len; i++) out += chars[buf[i] % chars.length];
+  return out;
+}
+
+module.exports = {
+  slugify, deslugify, isSlug, uniqueSlug,
+  slugWords, slugLength, truncateSlug, randomSlug,
+};

package/index.d.ts

@@ -0,0 +1,22 @@
+export interface SlugifyOptions {
+  separator?: string;
+  lower?: boolean;
+  strict?: boolean;
+  trim?: boolean;
+}
+export interface DeslugifyOptions {
+  separator?: string;
+  capitalize?: boolean;
+}
+export interface IsSlugOptions {
+  separator?: string;
+  allowUpper?: boolean;
+}
+export declare function slugify(str: unknown, opts?: SlugifyOptions): string;
+export declare function deslugify(slug: unknown, opts?: DeslugifyOptions): string;
+export declare function isSlug(str: unknown, opts?: IsSlugOptions): boolean;
+export declare function uniqueSlug(base: unknown, taken?: unknown[]): string;
+export declare function slugWords(slug: unknown, opts?: DeslugifyOptions): string[];
+export declare function slugLength(slug: unknown): number;
+export declare function truncateSlug(slug: unknown, max: number, opts?: DeslugifyOptions): string;
+export declare function randomSlug(len?: number, alphabet?: string): string;

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "slug-lib-js",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.1.3",
+  "description": "Small, dependency-free slug and URL-safe string utilities.",
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.cjs",
+      "require": "./index.cjs"
+    }
+  },
+  "files": [
+    "index.cjs",
+    "index.d.ts",
+    "README.md",
+    "assets"
+  ],
+  "keywords": [
+    "slug",
+    "slugify",
+    "url",
+    "string",
+    "transliterate",
+    "zero-dependency"
+  ],
+  "license": "MIT",
+  "engines": { "node": ">=14" },
+  "sideEffects": false
+}