# Check if name is available
npm view package-name-here

# If not found, it's available!
# Error: npm ERR! 404 'package-name-here' is not in this registry.

// Good names (descriptive, clear -- a developer should guess what it does from the name)
'date-formatter'          // Formats dates -- clear and specific
'json-validator'          // Validates JSON -- no ambiguity
'log-colorizer'           // Adds color to logs -- searchable
'express-rate-limiter'    // Rate limiting for Express -- framework prefix helps discovery

// Scoped packages (for personal/organization use)
// The @ prefix creates a namespace, like a folder for your packages
'@username/utilities'     // Personal namespace -- avoids collision with "utilities"
'@company/api-client'     // Organization namespace -- common for internal tooling
'@myorg/design-system'    // Scoped packages can be public or private

my-awesome-package/
├── src/                    # Source code
│   ├── index.js           # Main entry point
│   ├── utils/             # Utility functions
│   └── validators/        # Validation logic
├── test/                   # Test files
│   ├── index.test.js
│   └── utils.test.js
├── examples/               # Usage examples
│   └── basic-usage.js
├── .gitignore             # Git ignore rules
├── .npmignore             # NPM ignore rules
├── LICENSE                # License file
├── README.md              # Documentation
├── CHANGELOG.md           # Version history
└── package.json           # Package manifest

my-library/
├── src/
│   ├── index.js           # Public API
│   ├── core/              # Core functionality
│   │   ├── parser.js
│   │   └── validator.js
│   ├── utils/             # Helper functions
│   │   ├── formatters.js
│   │   └── constants.js
│   └── types/             # TypeScript definitions
│       └── index.d.ts
├── dist/                   # Compiled/bundled output
│   ├── index.js           # CommonJS
│   ├── index.esm.js       # ES Module
│   └── index.d.ts         # Type definitions
├── test/
│   ├── unit/              # Unit tests
│   ├── integration/       # Integration tests
│   └── fixtures/          # Test data
├── docs/                   # Additional documentation
│   ├── api.md
│   └── examples.md
├── scripts/                # Build/utility scripts
│   ├── build.js
│   └── release.js
├── .github/                # GitHub configuration
│   ├── workflows/
│   │   └── ci.yml
│   └── CONTRIBUTING.md
├── .eslintrc.json         # ESLint config
├── .prettierrc            # Prettier config
├── jest.config.js         # Jest config
├── tsconfig.json          # TypeScript config
├── rollup.config.js       # Bundler config
└── package.json

mkdir string-manipulator
cd string-manipulator

npm init

{
  "name": "string-manipulator",
  "version": "1.0.0",
  "description": "A lightweight utility for advanced string manipulation",
  "main": "index.js",
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage",
    "lint": "eslint src/",
    "lint:fix": "eslint src/ --fix",
    "format": "prettier --write \"src/**/*.js\"",
    "prepublishOnly": "npm test && npm run lint"
  },
  "keywords": [
    "string",
    "utility",
    "manipulation",
    "text",
    "format"
  ],
  "author": "Your Name <your.email@example.com>",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/yourusername/string-manipulator"
  },
  "bugs": {
    "url": "https://github.com/yourusername/string-manipulator/issues"
  },
  "homepage": "https://github.com/yourusername/string-manipulator#readme",
  "engines": {
    "node": ">=14.0.0"
  },
  "files": [
    "index.js",
    "src/",
    "README.md",
    "LICENSE"
  ],
  "devDependencies": {
    "eslint": "^8.50.0",
    "jest": "^29.7.0",
    "prettier": "^3.0.3"
  },
  "dependencies": {}
}

/**
 * String Manipulator - A utility library for advanced string operations
 * @module string-manipulator
 */

/**
 * Converts a string to title case
 * @param {string} str - The input string
 * @returns {string} The title-cased string
 * @example
 * toTitleCase('hello world') // 'Hello World'
 */
function toTitleCase(str) {
  // Defensive type checking -- public APIs should never silently coerce types.
  // Throwing a TypeError (not a generic Error) follows Node.js conventions
  // and helps consumers debug issues in their calling code.
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  return str
    .toLowerCase()              // Normalize first: "HELLO WORLD" -> "hello world"
    .split(' ')                 // Split into words by space
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))  // Capitalize first letter
    .join(' ');                 // Rejoin into a single string
}

/**
 * Converts a string to camelCase
 * @param {string} str - The input string
 * @returns {string} The camelCased string
 * @example
 * toCamelCase('hello world') // 'helloWorld'
 */
function toCamelCase(str) {
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  return str
    .toLowerCase()
    // This regex finds any non-alphanumeric character(s) followed by a letter,
    // and replaces the whole match with just the uppercase letter.
    // "hello-world" -> match "-w" -> replace with "W" -> "helloWorld"
    .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase());
}

/**
 * Converts a string to snake_case
 * @param {string} str - The input string
 * @returns {string} The snake_cased string
 * @example
 * toSnakeCase('Hello World') // 'hello_world'
 */
function toSnakeCase(str) {
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  return str
    .replace(/([A-Z])/g, '_$1')
    .toLowerCase()
    .replace(/\s+/g, '_')
    .replace(/^_/, '');
}

/**
 * Converts a string to kebab-case
 * @param {string} str - The input string
 * @returns {string} The kebab-cased string
 * @example
 * toKebabCase('Hello World') // 'hello-world'
 */
function toKebabCase(str) {
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  return str
    .replace(/([A-Z])/g, '-$1')
    .toLowerCase()
    .replace(/\s+/g, '-')
    .replace(/^-/, '');
}

/**
 * Truncates a string to a specified length
 * @param {string} str - The input string
 * @param {number} length - Maximum length
 * @param {string} [suffix='...'] - Suffix to append if truncated
 * @returns {string} The truncated string
 * @example
 * truncate('Hello World', 8) // 'Hello...'
 */
function truncate(str, length, suffix = '...') {
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  // If the string is already short enough, return it unchanged.
  // This avoids the edge case where slicing + suffix makes it longer.
  if (str.length <= length) {
    return str;
  }

  // Subtract the suffix length so the total output fits within `length`.
  // "Hello World" truncated to 8 with "..." -> "Hello" + "..." = "Hello..." (8 chars)
  return str.slice(0, length - suffix.length) + suffix;
}

/**
 * Reverses a string
 * @param {string} str - The input string
 * @returns {string} The reversed string
 * @example
 * reverse('hello') // 'olleh'
 */
function reverse(str) {
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  // Note: This simple approach breaks with Unicode characters like emojis
  // or multi-byte characters (e.g., "hello 🌍" reversed incorrectly).
  // For production use, consider Array.from(str).reverse().join('')
  // which handles Unicode code points correctly.
  return str.split('').reverse().join('');
}

/**
 * Counts the words in a string
 * @param {string} str - The input string
 * @returns {number} The word count
 * @example
 * wordCount('Hello world') // 2
 */
function wordCount(str) {
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  // trim() removes leading/trailing whitespace to avoid empty matches.
  // split(/\s+/) splits on one or more whitespace characters (handles tabs, newlines, double spaces).
  // filter(Boolean) removes empty strings from the array (e.g., if the input was all whitespace).
  return str.trim().split(/\s+/).filter(Boolean).length;
}

/**
 * Capitalizes the first letter of a string
 * @param {string} str - The input string
 * @returns {string} The capitalized string
 * @example
 * capitalize('hello') // 'Hello'
 */
function capitalize(str) {
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  return str.charAt(0).toUpperCase() + str.slice(1);
}

// Export all functions
module.exports = {
  toTitleCase,
  toCamelCase,
  toSnakeCase,
  toKebabCase,
  truncate,
  reverse,
  wordCount,
  capitalize
};

// Your functions here...

// CommonJS export
module.exports = {
  toTitleCase,
  toCamelCase,
  // ... other functions
};

// ES Module export (if supported)
if (typeof exports !== 'undefined') {
  exports.toTitleCase = toTitleCase;
  exports.toCamelCase = toCamelCase;
  // ... other exports
}

{
  "name": "string-manipulator",
  "version": "1.0.0",
  "main": "./dist/index.cjs",       // Entry point for require() -- CommonJS consumers
  "module": "./dist/index.mjs",      // Entry point for bundlers (Webpack, Rollup) -- enables tree-shaking
  "exports": {
    ".": {
      "require": "./dist/index.cjs", // When someone does: const x = require('string-manipulator')
      "import": "./dist/index.mjs",  // When someone does: import x from 'string-manipulator'
      "types": "./dist/index.d.ts"   // TypeScript type definitions -- resolved automatically
    }
  },
  "type": "module"                   // Tells Node.js to treat .js files as ES Modules by default
}

npm install --save-dev jest

const {
  toTitleCase,
  toCamelCase,
  toSnakeCase,
  toKebabCase,
  truncate,
  reverse,
  wordCount,
  capitalize
} = require('../src/index');

describe('String Manipulator', () => {
  describe('toTitleCase', () => {
    it('should convert string to title case', () => {
      expect(toTitleCase('hello world')).toBe('Hello World');
      expect(toTitleCase('THE QUICK BROWN FOX')).toBe('The Quick Brown Fox');
    });

    it('should handle single word', () => {
      expect(toTitleCase('hello')).toBe('Hello');
    });

    it('should throw error for non-string input', () => {
      expect(() => toTitleCase(123)).toThrow(TypeError);
      expect(() => toTitleCase(null)).toThrow(TypeError);
    });
  });

  describe('toCamelCase', () => {
    it('should convert string to camelCase', () => {
      expect(toCamelCase('hello world')).toBe('helloWorld');
      expect(toCamelCase('the-quick-brown-fox')).toBe('theQuickBrownFox');
    });

    it('should handle already camelCased strings', () => {
      expect(toCamelCase('helloWorld')).toBe('helloworld');
    });
  });

  describe('toSnakeCase', () => {
    it('should convert string to snake_case', () => {
      expect(toSnakeCase('Hello World')).toBe('hello_world');
      expect(toSnakeCase('theQuickBrownFox')).toBe('the_quick_brown_fox');
    });
  });

  describe('toKebabCase', () => {
    it('should convert string to kebab-case', () => {
      expect(toKebabCase('Hello World')).toBe('hello-world');
      expect(toKebabCase('theQuickBrownFox')).toBe('the-quick-brown-fox');
    });
  });

  describe('truncate', () => {
    it('should truncate string to specified length', () => {
      expect(truncate('Hello World', 8)).toBe('Hello...');
      expect(truncate('Hello', 10)).toBe('Hello');
    });

    it('should use custom suffix', () => {
      expect(truncate('Hello World', 8, '…')).toBe('Hello W…');
    });
  });

  describe('reverse', () => {
    it('should reverse a string', () => {
      expect(reverse('hello')).toBe('olleh');
      expect(reverse('12345')).toBe('54321');
    });
  });

  describe('wordCount', () => {
    it('should count words in a string', () => {
      expect(wordCount('Hello world')).toBe(2);
      expect(wordCount('The quick brown fox')).toBe(4);
    });

    it('should handle extra spaces', () => {
      expect(wordCount('  hello   world  ')).toBe(2);
    });
  });

  describe('capitalize', () => {
    it('should capitalize first letter', () => {
      expect(capitalize('hello')).toBe('Hello');
      expect(capitalize('world')).toBe('World');
    });
  });
});

# Run tests once
npm test

# Run tests in watch mode
npm run test:watch

# Generate coverage report
npm run test:coverage

-----------------|---------|----------|---------|---------|-------------------
File             | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
-----------------|---------|----------|---------|---------|-------------------
All files        |     100 |      100 |     100 |     100 |
 index.js        |     100 |      100 |     100 |     100 |
-----------------|---------|----------|---------|---------|-------------------

# String Manipulator

> A lightweight, zero-dependency utility library for advanced string manipulation in Node.js and browsers.

[![NPM Version](https://img.shields.io/npm/v/string-manipulator.svg)](https://www.npmjs.com/package/string-manipulator)
[![Build Status](https://github.com/yourusername/string-manipulator/workflows/CI/badge.svg)](https://github.com/yourusername/string-manipulator/actions)
[![Coverage](https://img.shields.io/codecov/c/github/yourusername/string-manipulator)](https://codecov.io/gh/yourusername/string-manipulator)
[![License](https://img.shields.io/npm/l/string-manipulator.svg)](LICENSE)

## Features

✅ Zero dependencies
✅ Lightweight (< 2KB gzipped)
✅ TypeScript support
✅ Full test coverage
✅ Works in Node.js and browsers
✅ ESM and CommonJS support

## Installation

```bash
npm install string-manipulator

yarn add string-manipulator

const { toTitleCase, toCamelCase, truncate } = require('string-manipulator');

// Title Case
toTitleCase('hello world'); // 'Hello World'

// Camel Case
toCamelCase('hello world'); // 'helloWorld'

// Truncate
truncate('Hello World', 8); // 'Hello...'

toTitleCase('hello world'); // 'Hello World'

toCamelCase('hello world'); // 'helloWorld'

<script src="https://unpkg.com/string-manipulator"></script>
<script>
  console.log(StringManipulator.toTitleCase('hello world'));
</script>

import { toTitleCase, toCamelCase } from 'string-manipulator';

const title: string = toTitleCase('hello world');

### CHANGELOG.md

```markdown
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

## [1.0.0] - 2024-01-15

### Added
- Initial release
- `toTitleCase()` function
- `toCamelCase()` function
- `toSnakeCase()` function
- `toKebabCase()` function
- `truncate()` function
- `reverse()` function
- `wordCount()` function
- `capitalize()` function

### Changed
- Nothing

### Fixed
- Nothing

## [0.1.0] - 2024-01-10

### Added
- Beta release
- Basic string manipulation functions

# Dependencies
node_modules/

# Test coverage
coverage/

# Build output
dist/
*.log

# Environment
.env
.env.local

# IDE
.vscode/
.idea/
*.swp
*.swo

# OS
.DS_Store
Thumbs.db

# Source files (if you build to dist/)
src/
test/

# Development files
.github/
.vscode/
coverage/
*.test.js
jest.config.js
.eslintrc.json
.prettierrc

# Documentation (keep README!)
docs/
examples/

# Git
.git/
.gitignore

MIT License

Copyright (c) 2024 Your Name

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

# Step 1: In your package directory -- register this package as a global link
npm link
# This creates a symlink: global node_modules/string-manipulator -> your local directory

# Step 2: In your test project -- connect to the linked package
npm link string-manipulator
# This creates a symlink: test-project/node_modules/string-manipulator -> global link -> your source

# Step 3: Now changes in your package source are instantly available
const { toTitleCase } = require('string-manipulator');
# Edits to src/index.js take effect immediately -- no reinstall needed

# In your test project
npm install ../path/to/string-manipulator

# Or in package.json
{
  "dependencies": {
    "string-manipulator": "file:../string-manipulator"
  }
}

mkdir test-package
cd test-package
npm init -y
npm install ../string-manipulator

// test.js
const { toTitleCase } = require('string-manipulator');

console.log(toTitleCase('hello world')); // Should output: Hello World

# Patch version (1.0.0 → 1.0.1)
npm version patch

# Minor version (1.0.0 → 1.1.0)
npm version minor

# Major version (1.0.0 → 2.0.0)
npm version major

# Specific version
npm version 1.2.3

# Pre-release versions
npm version prepatch  # 1.0.0 → 1.0.1-0
npm version preminor  # 1.0.0 → 1.1.0-0
npm version premajor  # 1.0.0 → 2.0.0-0

{
  "scripts": {
    "preversion": "npm test",
    "version": "npm run build && git add -A dist",
    "postversion": "git push && git push --tags"
  }
}

# Sign up at npmjs.com first, then:
npm login

# Verify login
npm whoami

# Run tests -- never publish without passing tests
npm test

# CRITICAL: Check what will be published BEFORE actually publishing
# This shows you every file that will be in the published package
npm pack --dry-run

# Create an actual tarball -- you can inspect it and install it locally
npm pack
# This creates string-manipulator-1.0.0.tgz
# Install it in a test project: npm install ./string-manipulator-1.0.0.tgz

# Public package
npm publish

# Scoped package (public)
npm publish --access public

# Test run (doesn't actually publish)
npm publish --dry-run

# Check package info
npm view string-manipulator

# Install and test
npm install string-manipulator

# Package name: @username/string-manipulator
npm publish --access public

# Requires paid NPM account
npm publish --access restricted

{
  "name": "@yourusername/string-manipulator",
  "version": "1.0.0",
  "publishConfig": {
    "access": "public"
  }
}

name: CI

on:
  push:
    branches: [ main ]          # Run on every push to main
  pull_request:
    branches: [ main ]          # Run on PRs targeting main

jobs:
  test:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        # Test against every Node.js version you claim to support in "engines"
        # This catches compatibility issues before your users do
        node-version: [14.x, 16.x, 18.x, 20.x]

    steps:
    - uses: actions/checkout@v3

    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}

    - name: Install dependencies
      run: npm ci              # Use 'ci' (not 'install') for reproducible installs from lockfile

    - name: Run linter
      run: npm run lint        # Catch style issues and potential bugs

    - name: Run tests
      run: npm test            # Your core quality gate

    - name: Generate coverage
      run: npm run test:coverage  # Track that test coverage does not regress

    - name: Upload coverage
      uses: codecov/codecov-action@v3
      with:
        file: ./coverage/coverage-final.json

name: Publish Package

on:
  release:
    types: [created]

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

    - uses: actions/setup-node@v3
      with:
        node-version: '18.x'
        registry-url: 'https://registry.npmjs.org'

    - run: npm ci
    - run: npm test
    - run: npm publish
      env:
        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

/**
 * Converts a string to title case
 */
export function toTitleCase(str: string): string;

/**
 * Converts a string to camelCase
 */
export function toCamelCase(str: string): string;

/**
 * Converts a string to snake_case
 */
export function toSnakeCase(str: string): string;

/**
 * Converts a string to kebab-case
 */
export function toKebabCase(str: string): string;

/**
 * Truncates a string to specified length
 */
export function truncate(str: string, length: number, suffix?: string): string;

/**
 * Reverses a string
 */
export function reverse(str: string): string;

/**
 * Counts words in a string
 */
export function wordCount(str: string): number;

/**
 * Capitalizes first letter
 */
export function capitalize(str: string): string;

{
  "types": "./index.d.ts",
  "typings": "./index.d.ts"
}

#!/usr/bin/env node

const { toTitleCase, toCamelCase } = require('../src/index');
const args = process.argv.slice(2);

if (args.length === 0) {
  console.log('Usage: string-manipulator <command> <text>');
  console.log('Commands: title, camel, snake, kebab');
  process.exit(1);
}

const [command, ...textParts] = args;
const text = textParts.join(' ');

switch (command) {
  case 'title':
    console.log(toTitleCase(text));
    break;
  case 'camel':
    console.log(toCamelCase(text));
    break;
  default:
    console.log('Unknown command:', command);
    process.exit(1);
}

{
  "bin": {
    "string-manipulator": "./bin/cli.js"
  }
}

# After npm install -g string-manipulator
string-manipulator title "hello world"
# Output: Hello World

{
  "peerDependencies": {
    "express": ">=4.0.0"
  },
  "peerDependenciesMeta": {
    "express": {
      "optional": false
    }
  }
}

{
  "optionalDependencies": {
    "colors": "^1.4.0"
  }
}

# Make changes to code
# Update tests
npm test

# Update version
npm version patch

# Publish update
npm publish

# Deprecate specific version
npm deprecate string-manipulator@1.0.0 "Please upgrade to 1.0.1"

# Deprecate all versions
npm deprecate string-manipulator "Package is no longer maintained"

# Unpublish specific version (within 72 hours)
npm unpublish string-manipulator@1.0.0

# Unpublish entire package (within 72 hours, if no dependents)
npm unpublish string-manipulator --force

function toTitleCase(str) {
  // Always validate input
  if (typeof str !== 'string') {
    throw new TypeError('Expected a string');
  }

  // Sanitize if needed
  str = str.trim();

  // Implement function logic
  // ...
}

// BAD - Never do this
function execute(code) {
  eval(code);
}

// GOOD - Use safe alternatives
function execute(data) {
  return JSON.parse(data);
}

# Regularly audit dependencies for known vulnerabilities
npm audit

# Fix vulnerabilities automatically (patches and minor versions only)
npm audit fix

# Check for outdated packages -- old dependencies accumulate vulnerabilities
npm outdated

# See why a dependency is in your tree (often transitive deps are the issue)
npm explain <package-name>

.env
.env.*
config/secrets.json
private/
*.key
*.pem

# Enable two-factor authentication
npm profile enable-2fa auth-and-writes