@ciwergrp/nuxid 1.6.2 → 1.6.3

package/docs/.docs/helpers/index.md

@@ -0,0 +1,34 @@
+---
+title: Helpers
+---
+
+# Helpers
+
+Nuxus exposes helper utilities for arrays, objects, numbers, strings, and dates.
+
+Helpers can be used in two styles:
+- Factory style (default): `array().first(...)`, `string().slug(...)`, `dt().now()`.
+- Prefix style: `First(...)`, `Slug(...)`, `Now(...)`.
+
+Configure the style in `nuxt.config.ts`:
+
+```ts
+export default defineNuxtConfig({
+  nuxid: {
+    helper: {
+      enabled: true,
+      config: {
+        style: 'factory',
+      },
+    },
+  },
+})
+```
+
+## Categories
+
+- [Array](/helpers/array)
+- [Object](/helpers/object)
+- [Number](/helpers/number)
+- [String](/helpers/string)
+- [Date](/helpers/date)

package/docs/.docs/helpers/number.md

@@ -0,0 +1,169 @@
+---
+title: Number Helpers
+outline: [2, 3]
+---
+
+# Number Helpers
+
+Number helpers handle formatting, parsing, units, and locale-aware output.
+
+Factory style:
+
+```ts
+const label = number().abbreviate(1200000)
+```
+
+Prefix style:
+
+```ts
+const label = Abbreviate(1200000)
+```
+
+## Methods
+
+### abbreviate
+Summary: Compacts large numbers using unit thresholds and `Intl.NumberFormat`.
+Parameters: `number` (number), `precision` (number, optional), `maxPrecision` (number | null, optional).
+- Returns: `string`.
+- Simple usage: `number().abbreviate(1500)` = `'1.5K'`
+- Advanced usage: `number().abbreviate(1500, 1, 2)` = `'1.5K'`
+
+### forHumans
+Summary: Outputs verbose unit labels using the same scale logic.
+Parameters: `number` (number), `precision` (number, optional), `maxPrecision` (number | null, optional).
+- Returns: `string`.
+- Simple usage: `number().forHumans(1200000)` = `'1.2 million'`
+- Advanced usage: `number().forHumans(1200000, 2)` = `'1.20 million'`
+
+### clamp
+Summary: Clamps a number between min and max with `Math.min/Math.max`.
+Parameters: `number` (number), `min` (number), `max` (number).
+- Returns: `number`.
+- Simple usage: `number().clamp(120, 0, 100)` = `100`
+- Advanced usage: `number().clamp(42, 0, 100)` = `42`
+
+### currency
+Summary: Formats currency with `Intl.NumberFormat` and a currency code.
+Parameters: `number` (number), `inCurrency` (string, optional), `locale` (string | null, optional), `precision` (number | null, optional).
+- Returns: `string`.
+- Simple usage: `number().currency(100, 'USD')` = `'$100.00'`
+- Advanced usage: `number().currency(100, 'EUR', 'de-DE', 2)` = `'100,00 €'`
+
+### defaultCurrency
+Summary: Returns the current default currency code from module state.
+Parameters: none.
+- Returns: `string`.
+- Simple usage: `number().defaultCurrency()` = `'USD'`
+- Advanced usage: `const code = number().defaultCurrency()` = `'USD'`
+
+### defaultLocale
+Summary: Returns the current default locale from module state.
+Parameters: none.
+- Returns: `string`.
+- Simple usage: `number().defaultLocale()` = `'en'`
+- Advanced usage: `const locale = number().defaultLocale()` = `'en'`
+
+### fileSize
+Summary: Formats bytes into human units using 1024 scaling and `format`.
+Parameters: `bytes` (number), `precision` (number, optional), `maxPrecision` (number | null, optional).
+- Returns: `string`.
+- Simple usage: `number().fileSize(1024 * 1024)` = `'1 MB'`
+- Advanced usage: `number().fileSize(1024 * 1024 * 3, 1, 2)` = `'3.0 MB'`
+
+### format
+Summary: Locale-aware number formatting with optional precision settings.
+Parameters: `number` (number), `precision` (number | null, optional), `maxPrecision` (number | null, optional), `locale` (string | null, optional).
+- Returns: `string`.
+- Simple usage: `number().format(1200.5)` = `'1,200.5'`
+- Advanced usage: `number().format(1200.5, 2, 2, 'id-ID')` = `'1.200,50'`
+
+### ordinal
+Summary: Adds ordinal suffix using `Intl.PluralRules`.
+Parameters: `number` (number), `locale` (string | null, optional).
+- Returns: `string`.
+- Simple usage: `number().ordinal(3)` = `'3rd'`
+- Advanced usage: `number().ordinal(21, 'en-US')` = `'21st'`
+
+### pairs
+Summary: Creates range pairs by stepping through the range.
+Parameters: `to` (number), `by` (number), `start` (number, optional), `offset` (number, optional).
+- Returns: `Array<[number, number]>`.
+- Simple usage: `number().pairs(10, 5)` = `[[0, 4], [5, 9]]`
+- Advanced usage: `number().pairs(20, 10, 0, 1)` = `[[0, 9], [10, 19]]`
+
+### parse
+Summary: Parses localized numeric strings after normalization.
+Parameters: `value` (string), `type` ('float' | 'int', optional), `locale` (string, optional).
+- Returns: `number | false`.
+- Simple usage: `number().parse('1,234.5')` = `1234.5`
+- Advanced usage: `number().parse('1.234,5', 'float', 'de-DE')` = `1234.5`
+
+### parseIntNumber
+Summary: Parses localized integer strings using `parse`.
+Parameters: `value` (string), `locale` (string, optional).
+- Returns: `number | false`.
+- Simple usage: `number().parseIntNumber('1,234')` = `1234`
+- Advanced usage: `number().parseIntNumber('1.234', 'de-DE')` = `1234`
+
+### parseFloatNumber
+Summary: Parses localized float strings using `parse`.
+Parameters: `value` (string), `locale` (string, optional).
+- Returns: `number | false`.
+- Simple usage: `number().parseFloatNumber('1,234.5')` = `1234.5`
+- Advanced usage: `number().parseFloatNumber('1.234,5', 'de-DE')` = `1234.5`
+
+### percentage
+Summary: Formats values as percentages using `Intl.NumberFormat`.
+Parameters: `number` (number), `precision` (number, optional), `maxPrecision` (number | null, optional), `locale` (string | null, optional).
+- Returns: `string`.
+- Simple usage: `number().percentage(25)` = `'25%'`
+- Advanced usage: `number().percentage(12.5, 2, 2, 'id-ID')` = `'12,50%'`
+
+### spell
+Summary: Spells numbers in English, with optional range thresholds.
+Parameters: `number` (number), `locale` (string | null, optional), `after` (number | null, optional), `until` (number | null, optional).
+- Returns: `string`.
+- Simple usage: `number().spell(42)` = `'forty-two'`
+- Advanced usage: `number().spell(42, 'en', 0, 1000)` = `'forty-two'`
+
+### spellOrdinal
+Summary: Spells ordinal words based on `spell` output.
+Parameters: `number` (number), `locale` (string | null, optional).
+- Returns: `string`.
+- Simple usage: `number().spellOrdinal(3)` = `'third'`
+- Advanced usage: `number().spellOrdinal(21, 'en')` = `'twenty-first'`
+
+### trim
+Summary: Removes trailing zeros by re-parsing the number.
+Parameters: `number` (number).
+- Returns: `number`.
+- Simple usage: `number().trim(10.0)` = `10`
+- Advanced usage: `number().trim(10.5000)` = `10.5`
+
+### useLocale
+Summary: Sets the default locale in module state.
+Parameters: `locale` (string).
+- Returns: `void`.
+- Simple usage: `number().useLocale('id-ID')` = `undefined`
+- Advanced usage: `number().useLocale(locale.value)` = `undefined`
+
+### withLocale
+Summary: Temporarily sets locale around a callback and restores afterward.
+Parameters: `locale` (string), `callback` (`() => T | Promise<T>`).
+- Returns: `T | Promise<T>`.
+- Simple usage: `number().withLocale('id-ID', () => number().format(1000))` = `'1.000'`
+- Advanced usage: `await number().withLocale('id-ID', async () => number().currency(100))` = `'$100.00'`
+
+### useCurrency
+Summary: Sets the default currency in module state.
+Parameters: `currency` (string).
+- Returns: `void`.
+- Simple usage: `number().useCurrency('EUR')` = `undefined`
+- Advanced usage: `number().useCurrency(userCurrency)` = `undefined`
+
+### withCurrency
+Summary: Temporarily sets currency around a callback and restores afterward.
+Parameters: `currency` (string), `callback` (`() => T | Promise<T>`).
+- Returns: `T | Promise<T>`.
+- Simple usage: `number().withCurrency('EUR', () => number().currency(100))` = `'€100.00'`
+- Advanced usage: `await number().withCurrency('EUR', async () => number().currency(100))` = `'€100.00'`

package/docs/.docs/helpers/object.md

@@ -0,0 +1,85 @@
+---
+title: Object Helpers
+outline: [2, 3]
+---
+
+# Object Helpers
+
+Object helpers provide safe access and mutation utilities with dot-path support.
+
+Factory style:
+
+```ts
+const value = object().get({ a: { b: 1 } }, 'a.b')
+```
+
+Prefix style:
+
+```ts
+const value = Get({ a: { b: 1 } }, 'a.b')
+```
+
+## Methods
+
+### add
+Summary: Sets a value only if the path is missing or null by combining `get` and `set`.
+Parameters: `target` (Record<string, any>), `path` (Path), `value` (any).
+- Returns: `T`.
+- Simple usage: `object().add(profile, 'name', 'Guest')` = `{ name: 'Guest' }`
+- Advanced usage: `object().add({ features: [{}] }, ['features', 0, 'enabled'], true)` = `{ features: [{ enabled: true }] }`
+
+### dot
+Summary: Flattens nested objects into dot-key paths via recursive traversal.
+Parameters: `target` (Record<string, any>), `prefix` (string, optional).
+- Returns: `Record<string, any>`.
+- Simple usage: `object().dot({ a: { b: 1 } })` = `{ 'a.b': 1 }`
+- Advanced usage: `object().dot({ a: { b: { c: 2 } } }, 'root')` = `{ 'root.a.b.c': 2 }`
+
+### except
+Summary: Omits top-level keys by copying entries that are not excluded.
+Parameters: `target` (Record<string, any>), `keys` (Path | Path[]).
+- Returns: `Record<string, any>`.
+- Simple usage: `object().except({ a: 1, b: 2 }, ['b'])` = `{ a: 1 }`
+- Advanced usage: `object().except({ id: 1, name: 'User', token: 'x' }, ['token'])` = `{ id: 1, name: 'User' }`
+
+### forget
+Summary: Removes a path from an object or array by traversing and deleting.
+Parameters: `target` (any), `paths` (Path | Path[]).
+- Returns: `any`.
+- Simple usage: `object().forget({ a: { b: 1 } }, 'a.b')` = `{ a: {} }`
+- Advanced usage: `object().forget([{ id: 1 }, { id: 2 }], [0, 'id'])` = `[{ id: 2 }]`
+
+### get
+Summary: Reads a value by dot path using `toPathArray` traversal.
+Parameters: `value` (any), `path` (Path), `defaultValue` (T, optional).
+- Returns: `T | undefined`.
+- Simple usage: `object().get({ a: { b: 1 } }, 'a.b')` = `1`
+- Advanced usage: `object().get({}, 'missing.key', 'fallback')` = `'fallback'`
+
+### has
+Summary: Checks if all provided paths exist using `get`.
+Parameters: `target` (any), `paths` (Path | Path[]).
+- Returns: `boolean`.
+- Simple usage: `object().has({ a: 1 }, 'a')` = `true`
+- Advanced usage: `object().has({ a: { b: 1 }, c: { d: 2 } }, ['a.b', 'c.d'])` = `true`
+
+### only
+Summary: Picks specific keys/paths by reading values and building a new object.
+Parameters: `target` (Record<string, any>), `keys` (Path | Path[]).
+- Returns: `Record<string, any>`.
+- Simple usage: `object().only({ a: 1, b: 2 }, ['a'])` = `{ a: 1 }`
+- Advanced usage: `object().only({ user: { id: 1, email: 'a@b.com' } }, ['user.id', 'user.email'])` = `{ 'user.id': 1, 'user.email': 'a@b.com' }`
+
+### set
+Summary: Sets a value by dot path and creates missing objects/arrays.
+Parameters: `target` (Record<string, any>), `path` (Path), `value` (any).
+- Returns: `T`.
+- Simple usage: `object().set({}, 'a.b', 1)` = `{ a: { b: 1 } }`
+- Advanced usage: `object().set({}, ['items', 0, 'name'], 'Item')` = `{ items: [{ name: 'Item' }] }`
+
+### undot
+Summary: Converts dot-key objects into nested objects using `set`.
+Parameters: `target` (Record<string, any>).
+- Returns: `Record<string, any>`.
+- Simple usage: `object().undot({ 'a.b': 1 })` = `{ a: { b: 1 } }`
+- Advanced usage: `object().undot({ 'a.0.name': 'Item' })` = `{ a: [{ name: 'Item' }] }`

package/docs/.docs/helpers/string.md

@@ -0,0 +1,316 @@
+---
+title: String Helpers
+outline: [2, 3]
+---
+
+# String Helpers
+
+String helpers cover casing, trimming, matching, and slug formatting.
+
+Factory style:
+
+```ts
+const slug = string().slug('Hello World')
+```
+
+Prefix style:
+
+```ts
+const slug = Slug('Hello World')
+```
+
+## Methods
+
+### after
+Summary: Returns substring after the first occurrence using `indexOf` and `slice`.
+Parameters: `value` (string), `search` (string).
+- Returns: `string`.
+- Simple usage: `string().after('foo-bar', '-')` = `'bar'`
+- Advanced usage: `string().after('foo-bar-baz', '-')` = `'bar-baz'`
+
+### afterLast
+Summary: Returns substring after the last occurrence using `lastIndexOf`.
+Parameters: `value` (string), `search` (string).
+- Returns: `string`.
+- Simple usage: `string().afterLast('foo-bar', '-')` = `'bar'`
+- Advanced usage: `string().afterLast('foo-bar-baz', '-')` = `'baz'`
+
+### ascii
+Summary: Transliterate and strip non-ASCII characters.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().ascii('Café')` = `'Cafe'`
+- Advanced usage: `string().ascii('你好 Cafe')` = `' Cafe'`
+
+### before
+Summary: Returns substring before the first occurrence.
+Parameters: `value` (string), `search` (string).
+- Returns: `string`.
+- Simple usage: `string().before('foo-bar', '-')` = `'foo'`
+- Advanced usage: `string().before('foo-bar-baz', '-')` = `'foo'`
+
+### beforeLast
+Summary: Returns substring before the last occurrence.
+Parameters: `value` (string), `search` (string).
+- Returns: `string`.
+- Simple usage: `string().beforeLast('foo-bar', '-')` = `'foo'`
+- Advanced usage: `string().beforeLast('foo-bar-baz', '-')` = `'foo-bar'`
+
+### between
+Summary: Returns substring between markers using `after` then `before`.
+Parameters: `value` (string), `from` (string), `to` (string).
+- Returns: `string`.
+- Simple usage: `string().between('foo[bar]baz', '[', ']')` = `'bar'`
+- Advanced usage: `string().between('a{b}c{d}', '{', '}')` = `'b'`
+
+### betweenFirst
+Summary: Returns substring between the first pair of markers.
+Parameters: `value` (string), `from` (string), `to` (string).
+- Returns: `string`.
+- Simple usage: `string().betweenFirst('foo[bar]baz', '[', ']')` = `'bar'`
+- Advanced usage: `string().betweenFirst('a{b}c{d}', '{', '}')` = `'b'`
+
+### camel
+Summary: Converts to camelCase by splitting words and capitalizing.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().camel('hello world')` = `'helloWorld'`
+- Advanced usage: `string().camel('hello-world_test')` = `'helloWorldTest'`
+
+### contains
+Summary: Checks if any substring exists using `includes`.
+Parameters: `value` (string), `search` (string | string[]).
+- Returns: `boolean`.
+- Simple usage: `string().contains('hello', 'ell')` = `true`
+- Advanced usage: `string().contains('hello', ['x', 'ell'])` = `true`
+
+### containsAll
+Summary: Checks if all substrings exist using `includes`.
+Parameters: `value` (string), `search` (string[]).
+- Returns: `boolean`.
+- Simple usage: `string().containsAll('hello', ['he', 'lo'])` = `true`
+- Advanced usage: `string().containsAll('hello world', ['hello', 'world'])` = `true`
+
+### endsWith
+Summary: Checks suffix match with one or more candidates.
+Parameters: `value` (string), `search` (string | string[]).
+- Returns: `boolean`.
+- Simple usage: `string().endsWith('file.ts', '.ts')` = `true`
+- Advanced usage: `string().endsWith('file.ts', ['.js', '.ts'])` = `true`
+
+### finish
+Summary: Ensures the string ends with a suffix.
+Parameters: `value` (string), `suffix` (string).
+- Returns: `string`.
+- Simple usage: `string().finish('path', '/')` = `'path/'`
+- Advanced usage: `string().finish('path/', '/')` = `'path/'`
+
+### defaultLocale
+Summary: Returns the current default locale for string helpers.
+Parameters: none.
+- Returns: `string`.
+- Simple usage: `string().defaultLocale()` = `'en'`
+- Advanced usage: `const locale = string().defaultLocale()` = `'en'`
+
+### kebab
+Summary: Converts to kebab-case by splitting words and joining with `-`.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().kebab('HelloWorld')` = `'hello-world'`
+- Advanced usage: `string().kebab('hello_world test')` = `'hello-world-test'`
+
+### lcfirst
+Summary: Lowercases the first character.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().lcfirst('Hello')` = `'hello'`
+- Advanced usage: `string().lcfirst('URLValue')` = `'uRLValue'`
+
+### length
+Summary: Returns Unicode-aware character length.
+Parameters: `value` (string).
+- Returns: `number`.
+- Simple usage: `string().length('hello')` = `5`
+- Advanced usage: `string().length('👋🌍')` = `2`
+
+### lower
+Summary: Lowercases the string with `toLowerCase`.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().lower('Hello')` = `'hello'`
+- Advanced usage: `string().lower('HELLO WORLD')` = `'hello world'`
+
+### ltrim
+Summary: Trims left side using `trimStart` or a mask regex.
+Parameters: `value` (string), `mask` (string, optional).
+- Returns: `string`.
+- Simple usage: `string().ltrim('  hello ')` = `'hello'`
+- Advanced usage: `string().ltrim('--hello', '-')` = `'hello'`
+
+### padBoth
+Summary: Pads both sides to a target length.
+Parameters: `value` (string), `length` (number), `pad` (string, optional).
+- Returns: `string`.
+- Simple usage: `string().padBoth('a', 3, '_')` = `_a_`
+- Advanced usage: `string().padBoth('hello', 10, '.')` = `'..hello...'`
+
+### padLeft
+Summary: Pads on the left using `padStart`.
+Parameters: `value` (string), `length` (number), `pad` (string, optional).
+- Returns: `string`.
+- Simple usage: `string().padLeft('1', 3, '0')` = `'001'`
+- Advanced usage: `string().padLeft('abc', 5, '-')` = `'--abc'`
+
+### padRight
+Summary: Pads on the right using `padEnd`.
+Parameters: `value` (string), `length` (number), `pad` (string, optional).
+- Returns: `string`.
+- Simple usage: `string().padRight('1', 3, '0')` = `'100'`
+- Advanced usage: `string().padRight('abc', 5, '-')` = `'abc--'`
+
+### plural
+Summary: Pluralizes using the `pluralize` library.
+Parameters: `value` (string), `count` (number, optional).
+- Returns: `string`.
+- Simple usage: `string().plural('car')` = `'cars'`
+- Advanced usage: `string().plural('car', 2)` = `'cars'`
+
+### pluralStudly
+Summary: Pluralizes a StudlyCase version of the input.
+Parameters: `value` (string), `count` (number, optional).
+- Returns: `string`.
+- Simple usage: `string().pluralStudly('user')` = `'Users'`
+- Advanced usage: `string().pluralStudly('user_profile', 2)` = `'UserProfiles'`
+
+### remove
+Summary: Removes substrings by split/join.
+Parameters: `value` (string), `search` (string | string[]).
+- Returns: `string`.
+- Simple usage: `string().remove('foo-bar', '-')` = `'foobar'`
+- Advanced usage: `string().remove('foo-bar-baz', ['-', 'baz'])` = `'foo-bar-'`
+
+### replace
+Summary: Replaces matches using `String.prototype.replace`.
+Parameters: `value` (string), `search` (string | RegExp), `replaceWith` (string).
+- Returns: `string`.
+- Simple usage: `string().replace('foo', 'o', '0')` = `'f0o'`
+- Advanced usage: `string().replace('foo', /o/g, '0')` = `'f00'`
+
+### replaceFirst
+Summary: Replaces the first occurrence only.
+Parameters: `value` (string), `search` (string | RegExp), `replaceWith` (string).
+- Returns: `string`.
+- Simple usage: `string().replaceFirst('foo', 'o', '0')` = `'f0o'`
+- Advanced usage: `string().replaceFirst('foo', /o/g, '0')` = `'f0o'`
+
+### replaceLast
+Summary: Replaces the last occurrence.
+Parameters: `value` (string), `search` (string), `replaceWith` (string).
+- Returns: `string`.
+- Simple usage: `string().replaceLast('foo', 'o', '0')` = `'fo0'`
+- Advanced usage: `string().replaceLast('foo-bar-foo', 'foo', '0')` = `'foo-bar-0'`
+
+### rtrim
+Summary: Trims right side using `trimEnd` or a mask regex.
+Parameters: `value` (string), `mask` (string, optional).
+- Returns: `string`.
+- Simple usage: `string().rtrim('  hello ')` = `'hello'`
+- Advanced usage: `string().rtrim('hello---', '-')` = `'hello'`
+
+### singular
+Summary: Singularizes using the `pluralize` library.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().singular('cars')` = `'car'`
+- Advanced usage: `string().singular('people')` = `'person'`
+
+### slug
+Summary: Slugifies with `@sindresorhus/slugify` and locale support.
+Parameters: `value` (string), `separator` (string, optional).
+- Returns: `string`.
+- Simple usage: `string().slug('Hello World')` = `'hello-world'`
+- Advanced usage: `string().slug('Hello World', '_')` = `'hello_world'`
+
+### snake
+Summary: Converts to snake_case by splitting words and joining with `_`.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().snake('HelloWorld')` = `'hello_world'`
+- Advanced usage: `string().snake('hello-world test')` = `'hello_world_test'`
+
+### start
+Summary: Ensures the string starts with a prefix.
+Parameters: `value` (string), `prefix` (string).
+- Returns: `string`.
+- Simple usage: `string().start('path', '/')` = `'/path'`
+- Advanced usage: `string().start('/path', '/')` = `'/path'`
+
+### startsWith
+Summary: Checks prefix match with one or more candidates.
+Parameters: `value` (string), `search` (string | string[]).
+- Returns: `boolean`.
+- Simple usage: `string().startsWith('file.ts', 'file')` = `true`
+- Advanced usage: `string().startsWith('file.ts', ['file', 'app'])` = `true`
+
+### studly
+Summary: Converts to StudlyCase by word splitting and capitalizing.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().studly('hello world')` = `'HelloWorld'`
+- Advanced usage: `string().studly('hello-world_test')` = `'HelloWorldTest'`
+
+### title
+Summary: Converts to Title Case by word splitting and capitalizing.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().title('hello world')` = `'Hello World'`
+- Advanced usage: `string().title('hello-world_test')` = `'Hello World Test'`
+
+### transliterate
+Summary: Converts to Latin characters using transliteration.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().transliterate('你好')` = `'Ni Hao'`
+- Advanced usage: `string().transliterate('Café')` = `'Cafe'`
+
+### ucfirst
+Summary: Uppercases the first character.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().ucfirst('hello')` = `'Hello'`
+- Advanced usage: `string().ucfirst('hELLO')` = `'HELLO'`
+
+### upper
+Summary: Uppercases the string with `toUpperCase`.
+Parameters: `value` (string).
+- Returns: `string`.
+- Simple usage: `string().upper('Hello')` = `'HELLO'`
+- Advanced usage: `string().upper('hello world')` = `'HELLO WORLD'`
+
+### wordCount
+Summary: Counts words by trimming and splitting on whitespace.
+Parameters: `value` (string).
+- Returns: `number`.
+- Simple usage: `string().wordCount('hello world')` = `2`
+- Advanced usage: `string().wordCount('  hello   world  ')` = `2`
+
+### words
+Summary: Limits to a word count and appends a suffix.
+Parameters: `value` (string), `wordsCount` (number), `end` (string, optional).
+- Returns: `string`.
+- Simple usage: `string().words('hello world', 1)` = `'hello...'`
+- Advanced usage: `string().words('hello world', 1, ' (more)')` = `'hello (more)'`
+
+### useLocale
+Summary: Sets the default locale for string helpers.
+Parameters: `locale` (string).
+- Returns: `void`.
+- Simple usage: `string().useLocale('id-ID')` = `undefined`
+- Advanced usage: `string().useLocale(locale.value)` = `undefined`
+
+### withLocale
+Summary: Temporarily sets locale around a callback and restores afterward.
+Parameters: `locale` (string), `callback` (`() => T | Promise<T>`).
+- Returns: `T | Promise<T>`.
+- Simple usage: `string().withLocale('id-ID', () => string().slug('Halo Dunia'))` = `'halo-dunia'`
+- Advanced usage: `await string().withLocale('id-ID', async () => string().slug('Halo Dunia'))` = `'halo-dunia'`

package/docs/.docs/index.md

@@ -0,0 +1,17 @@
+# Nuxid Docs
+
+Nuxid is a list of type-safe helpers specifically made for Nuxt version >= 4 for developers who need to quickly hop into the business logic development, skipping all the unnecessary times needed to develop helpers like validations, transformers, or composables.
+
+- [Quick Start](/form-validation/quick-start)
+- [createValidationRules](/form-validation/create-validation-rules)
+- [Request Generator](/form-validation/request-generator)
+- [Available Rules](/form-validation/rules)
+- [Configuration](/configuration)
+- [Structure Directory](/structure-directory)
+- [Helpers](/helpers/)
+- [Data Fetching](/composables/use-http)
+- [useTitle](/composables/use-title)
+- [useBreadcrumbs](/composables/use-breadcrumbs)
+- [useRouteQuery](/composables/use-route-query)
+- [useQueryFilters](/composables/use-query-filters)
+- [useVersionUpdater](/composables/use-version-updater)

package/docs/.docs/structure-directory.md

@@ -0,0 +1,28 @@
+---
+title: Structure Directory
+---
+
+# Structure Directory
+
+This module is optimized for a Nuxt + pnpm monorepo where each product/domain is a separate Nuxt app under `apps/`, while shared functionality lives in `layers/` as Nuxt layers. The repository root is the single workspace that owns dependency versions, linting, TypeScript config, and other tooling, so all apps and layers stay in sync. By keeping apps thin and moving cross-cutting concerns into layers (UI, composables, config, and utilities), you avoid duplication while keeping ownership clear and scaling across multiple teams or products.
+
+Recommended top-level structure (layout overview):
+
+```
+root/
+  apps/                # per-domain Nuxt apps
+  layers/              # shared Nuxt layers (ui, config, composables, etc.)
+  package.json         # workspace dependencies
+  pnpm-workspace.yaml  # workspace map
+  eslint.config.mjs    # shared lint config
+  tsconfig.json        # shared TS config
+  docker-compose.yml   # local infra (optional)
+  README.md            # repo-level docs
+```
+
+Inside `apps/`, each app represents a specific domain or product and owns its `nuxt.config.ts`, routes, and app-only modules. Inside `layers/`, each folder is a Nuxt layer that can expose components, composables, auto-imports, or module defaults to any app that extends it. This keeps shared functionality centralized while still allowing each app to compose only the layers it needs.
+
+Example paths:
+
+- `apps/admin/nuxt.config.ts`
+- `layers/ui/nuxt.config.ts`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciwergrp/nuxid",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "All-in-one essential modules for Nuxt",
   "repository": {
     "type": "git",
@@ -17,6 +17,7 @@
   },
   "license": "MIT",
   "type": "module",
+  "types": "./dist/types.d.mts",
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
@@ -38,6 +39,7 @@
     "dist",
     "bin",
     "console",
+    "docs/.docs",
     "package.json",
     "README.md"
   ],