js-01-slugify

# Slugify a title

Implement an ES module **`solution.js`** exporting a single function:

```js
export function slugify(input) { /* ... */ }
```

Convert a human title string into a URL slug:

- Lowercase the whole string.
- Treat **any character that is not an ASCII letter (`a–z`) or digit (`0–9`) as a separator** —
  this includes spaces, punctuation, underscores, and non-ASCII letters.
- Replace each **run** of one or more separators with a **single** hyphen (`-`).
- Strip any leading or trailing hyphens from the result.

Return the resulting slug (a string). An input made entirely of separators returns `""`.

Examples:
```js
slugify("Hello World")          // => "hello-world"
slugify("  Hello,  World!  ")   // => "hello-world"
slugify("already-clean")        // => "already-clean"
slugify("Top 10 Tips")          // => "top-10-tips"
slugify("a---b__c")             // => "a-b-c"
slugify("@#$%")                 // => ""
```

import { test } from "node:test";
import { strict as assert } from "node:assert";
import { slugify } from "./solution.js";

test("spaces become single hyphens", () => {
  assert.equal(slugify("Hello World"), "hello-world");
});

test("punctuation collapses and ends are trimmed", () => {
  assert.equal(slugify("  Hello,  World!  "), "hello-world");
});

test("already-clean input is unchanged", () => {
  assert.equal(slugify("already-clean"), "already-clean");
});

test("digits are preserved", () => {
  assert.equal(slugify("Top 10 Tips"), "top-10-tips");
});

test("runs of mixed separators collapse to one hyphen", () => {
  assert.equal(slugify("a---b__c"), "a-b-c");
});

test("leading and trailing junk is trimmed", () => {
  assert.equal(slugify("--Foo Bar--"), "foo-bar");
});

test("all-separator input becomes empty string", () => {
  assert.equal(slugify("@#$%"), "");
});

test("empty string stays empty", () => {
  assert.equal(slugify(""), "");
});

test("non-ASCII letters act as separators", () => {
  assert.equal(slugify("café crème"), "caf-cr-me");
});

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

To solve this problem, we need to convert a human-readable title string into a URL slug. The URL slug must follow specific formatting rules, such as lowercasing all characters, treating certain characters as separators, and ensuring that runs of separators are replaced with a single hyphen. Additionally, leading and trailing hyphens must be removed, and inputs consisting entirely of separators should return an empty string.

### Approach
The approach to solve this problem involves the following steps:

1. **Lowercase Conversion**: Convert the entire input string to lowercase to ensure uniformity.
2. **Separator Replacement**: Replace any sequence of non-alphanumeric characters (including spaces, punctuation, and non-ASCII letters) with a single hyphen.
3. **Trim Leading and Trailing Hyphens**: Remove any hyphens that appear at the beginning or end of the resulting string.
4. **Handle Edge Cases**: If the resulting string is empty after processing, return an empty string.

This approach efficiently handles all specified requirements using regular expressions to identify and replace non-alphanumeric characters, and then trims the result to ensure no leading or trailing hyphens.

### Solution Code

```js
export function slugify(input) {
    const lowerInput = input.toLowerCase();
    let withDashes = lowerInput.replace(/[^a-z0-9]+/g, '-');
    withDashes = withDashes.replace(/^-+/, '').replace(/-+$/, '');
    return withDashes;
}
```

### Explanation
1. **Lowercase Conversion**: The input string is converted to lowercase using `toLowerCase()`, ensuring that all characters are in a uniform format.
2. **Separator Replacement**: The regular expression `[^a-z0-9]+` is used to match any sequence of non-alphanumeric characters. Each sequence is replaced with a single hyphen, effectively normalizing the string.
3. **Trim Leading and Trailing Hyphens**: The resulting string is processed to remove any leading or trailing hyphens using `replace(/^-+/, '')` and `replace(/-+$/, '')`.
4. **Edge Case Handling**: If the resulting string is empty after processing, it is returned as is, ensuring that inputs consisting entirely of separators return an empty string.

This method ensures that the resulting URL slug is clean, properly formatted, and adheres to the specified rules.

Okay, I need to write a JavaScript function called slugify that takes an input string and converts it into a URL slug according to the specified rules. Let me think about how to approach this.

First, the function should lowercase the entire input string. That's straightforward using the toLowerCase() method.

Next, any character that's not an ASCII letter or digit is considered a separator. So, I need to identify these characters. ASCII letters are a-z and A-Z, and digits are 0-9. So, any character that doesn't match [a-zA-Z0-9] is a separator.

The task is to replace each run of one or more separators with a single hyphen. So, for example, if there are multiple spaces or a mix of punctuation, they all become a single '-'.

Also, leading and trailing hyphens should be stripped from the result. And if the input is entirely separators, return an empty string.

Hmm, how can I process the string to achieve this? Maybe using a regular expression would be efficient.

Let me think about the steps:

1. Convert the entire string to lowercase.
2. Replace any sequence of non-alphanumeric characters with a single hyphen.
3. Then, remove any leading or trailing hyphens.
4. Also, if the string is empty after processing, return an empty string.

Wait, but how do I handle the replacement? I can use a regex to match one or more non-alphanumeric characters and replace them with a hyphen.

The regex for non-alphanumeric is [^a-zA-Z0-9]. So, I can replace any occurrence of one or more of these with '-'.

But wait, I should make sure that after replacement, multiple hyphens are not created. For example, if the input is "a---b__c", the regex will replace each run of non-alphanumerics with a single '-', so it becomes "a-b-c".

So the plan is:

- Convert input to lowercase.
- Replace all sequences of non-alphanumerics with '-'.
- Trim leading and trailing '-'.
- If the result is empty, return empty string.

Wait, but what about the case where the string is something like "   " (all separators)? After replacement, it would be "----", then trimming gives empty string, which is correct.

So, let's outline the steps in code:

function slugify(input) {
    // Step 1: Lowercase the input
    const lowerInput = input.toLowerCase();

    // Step 2: Replace runs of non-alphanumerics with '-'
    let withDashes = lowerInput.replace(/[^a-z0-9]+/g, '-');

    // Step 3: Trim leading and trailing '-'
    let trimmed = withDashes.replace(/^-+| -+$/g, ''); // Wait, no, the correct way is to replace leading and trailing hyphens.

    // Alternatively, use trim() but for hyphens. So, replace ^-+ and -+$.
    trimmed = withDashes.replace(/^-+/, '').replace(/-+$/, '');

    // Or, more efficiently, use a single replace with a regex that matches leading or trailing hyphens.
    // So, replace /^-+|-+$/g, '' ?

    // Wait, no. Because the replace function can take a regex with groups. Maybe using a regex that matches either the start or end.

    // Alternatively, use split and join, but that might complicate things.

    // So, perhaps the best way is to replace leading hyphens and then trailing hyphens.

    // After that, if the string is empty, return it.

    return trimmed;
}

Wait, but let's test this logic with some examples.

Example 1: "Hello World" → lower → "hello world" → replace spaces → "hello-world" → no leading/trailing, so result is "hello-world". Correct.

Example 2: "  Hello,  World!  " → lower → "  hello,  world!  " → replace non-alphanumerics (space, comma, etc.) → "hello-world" → after trimming, same. Correct.

Example 3: "already-clean" → no changes except lower, which it already is. So remains "already-clean". Correct.

Example 4: "Top 10 Tips" → becomes "top-10-tips". Correct.

Example 5: "a---b__c" → becomes "a-b-c". Correct.

Example 6: "@#$%" → lower is same, replace all with '-', so becomes "----", then trimming gives empty string. Correct.

Another test case: "a b" → becomes "a-b".

What about a string like "a--b"? The regex will replace the two '-' with a single '-', so it becomes "a-b".

Wait, no. Wait, the regex [^a-z0-9]+ matches any sequence of non-alphanumerics. So in "a--b", the '--' is two hyphens, which are non-alphanumerics. So they are replaced with a single '-', resulting in "a-b".

Yes, that's correct.

Another test case: "a___b" → becomes "a-b".

What about a string that starts or ends with non-alphanumerics? Like "-abc" → becomes "abc". "abc-" → becomes "abc".

What about a string like "abc-def-ghi"? It remains as is.

So, the code seems to handle these cases.

Wait, but in the code, after replacing, we have to trim the leading and trailing hyphens. So, in the code, after the replace, we do:

withDashes = lowerInput.replace(/[^a-z0-9]+/g, '-');

Then, trimmed = withDashes.replace(/^-+/, '').replace(/-+$/, '');

Wait, but in JavaScript, the replace function can take a regex and a replacement string. So, for leading hyphens, the regex is ^-+, which matches one or more hyphens at the start. Similarly, for trailing, it's -+$.

So, the code would correctly remove leading and trailing hyphens.

Putting it all together:

export function slugify(input) {
    const lowerInput = input.toLowerCase();
    let withDashes = lowerInput.replace(/[^a-z0-9]+/g, '-');
    withDashes = withDashes.replace(/^-+/, ''); // remove leading
    withDashes = withDashes.replace(/-+$/, ''); // remove trailing
    return withDashes === '' ? '' : withDashes;
}

Wait, but what if after replacing, the string is empty? Like the input is "@#$%", which becomes "----", then trimming gives empty string. So the function returns empty string.

Another case: input is "a", which becomes "a".

Wait, but what about input is "a-b-c"? It remains "a-b-c".

What about input is "a  b"? It becomes "a-b".

Yes.

Wait, but in the code, after the first replace, the string could be empty. For example, if the input is "!!!", then lowerInput is "!!!", then replace becomes "---", then trimming gives empty string.

So the code returns empty string.

Another case: input is "a-b-c-d", which becomes "a-b-c-d".

So, the code seems to handle all cases.

Wait, but in the code, after the f
…[2141 chars elided]…
ce the '---' with '-', the '__' with '-', resulting in "a-b-c".

Yes.

Another test case: input is "a b c". The code replaces the spaces with '-', resulting in "a-b-c".

Yes.

What about a string with underscores, like "hello_world"? The code replaces the underscore with '-', resulting in "hello-world".

Yes.

What about a string with mixed separators, like "hello!world#this"? It becomes "hello-world-this".

Yes.

So, the code seems to handle all these cases.

Wait, but in the code, the regex is [^a-z0-9]+, but in JavaScript, the replace function is case-sensitive. But since we've already lowercased the input, it's okay.

Yes, because after lowercasing, all letters are lowercase, so the regex [^a-z0-9] correctly matches any non-lowercase letter or digit.

So, the code should work.

Wait, but what about Unicode characters? The problem statement says that any non-ASCII letters are treated as separators. So, for example, 'ç' is an ASCII letter? Wait, no. 'ç' is a Latin character, but in ASCII, letters are only a-z and A-Z. So, any other letters, like accented ones, are considered separators.

So, the regex [^a-z0-9] will match them, and replace with '-'.

Yes, that's correct.

So, the code should handle all cases as required.

Now, let's write the code.

The function is to be exported as an ES module.

So, the code will be:

export function slugify(input) {
    const lowerInput = input.toLowerCase();
    let withDashes = lowerInput.replace(/[^a-z0-9]+/g, '-');
    withDashes = withDashes.replace(/^-+/, ''); // Remove leading hyphens
    withDashes = withDashes.replace(/-+$/, ''); // Remove trailing hyphens
    return withDashes;
}

Wait, but what if after replacing, the string is empty? For example, input is "@#$%", which becomes "----", then trimming gives empty string. So, the function returns empty string.

Yes.

Another test case: input is "   ", which becomes "   " → lower is same, then replace with '---', then trimming gives empty string.

Yes.

So, the code should handle all cases.

I think this should work.