@skmtc/core 0.0.828 → 0.0.829

package/esm/helpers/strings.d.ts

@@ -77,6 +77,8 @@ export declare const decapitalize: (str: string) => string;
 type CamelCaseOptions = {
     /** Whether to capitalize the first character (PascalCase) */
     upperFirst?: boolean;
+    /** Whether to retain underscores in place when converting strings */
+    retainUnderscores?: boolean;
 };
 /**
  * Converts a string to camelCase, removing non-alphanumeric characters.
@@ -88,6 +90,7 @@ type CamelCaseOptions = {
  * @param str - The string to convert to camelCase
  * @param options - Options to control the conversion
  * @param options.upperFirst - Whether to capitalize the first character (default: false)
+ * @param options.retainUnderscores - Whether to retain underscores in place (default: false)
  * @returns The camelCase version of the input string
  *
  * @example Basic usage
@@ -110,7 +113,15 @@ type CamelCaseOptions = {
  * camelCase('XML_HTTP_Request'); // 'xmlHttpRequest'
  * camelCase('2fa-enabled'); // '2faEnabled'
  * ```
+ *
+ * @example Retaining underscores (retainUnderscores)
+ * ```typescript
+ * camelCase('user_name', { retainUnderscores: true }); // 'user_name'
+ * camelCase('api-key_token', { retainUnderscores: true }); // 'apiKey_token'
+ * camelCase('get_user_by_id', { retainUnderscores: true }); // 'get_user_by_id'
+ * camelCase('user_profile', { upperFirst: true, retainUnderscores: true }); // 'User_profile'
+ * ```
  */
-export declare const camelCase: (str: string, { upperFirst }?: CamelCaseOptions) => string;
+export declare const camelCase: (str: string, { upperFirst, retainUnderscores }?: CamelCaseOptions) => string;
 export {};
 //# sourceMappingURL=strings.d.ts.map

package/esm/helpers/strings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,iBAAgB,gBAAqB,KAAG,MAgB9E,CAAA"}
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,oCAAmC,gBAAqB,KAAG,MA+BjG,CAAA"}

package/esm/helpers/strings.js

@@ -85,6 +85,7 @@ export const decapitalize = (str) => {
  * @param str - The string to convert to camelCase
  * @param options - Options to control the conversion
  * @param options.upperFirst - Whether to capitalize the first character (default: false)
+ * @param options.retainUnderscores - Whether to retain underscores in place (default: false)
  * @returns The camelCase version of the input string
  *
  * @example Basic usage
@@ -107,16 +108,38 @@ export const decapitalize = (str) => {
  * camelCase('XML_HTTP_Request'); // 'xmlHttpRequest'
  * camelCase('2fa-enabled'); // '2faEnabled'
  * ```
+ *
+ * @example Retaining underscores (retainUnderscores)
+ * ```typescript
+ * camelCase('user_name', { retainUnderscores: true }); // 'user_name'
+ * camelCase('api-key_token', { retainUnderscores: true }); // 'apiKey_token'
+ * camelCase('get_user_by_id', { retainUnderscores: true }); // 'get_user_by_id'
+ * camelCase('user_profile', { upperFirst: true, retainUnderscores: true }); // 'User_profile'
+ * ```
  */
-export const camelCase = (str, { upperFirst } = {}) => {
-    let doCapitalize = Boolean(upperFirst);
-    const camelCased = str.replace(/[^a-zA-Z0-9]+([a-zA-Z0-9]+)/g, (_, matched) => {
-        if (doCapitalize) {
-            return capitalize(matched);
+export const camelCase = (str, { upperFirst, retainUnderscores } = {}) => {
+    // Check if string starts with a delimiter
+    const startsWithDelimiter = retainUnderscores
+        ? /^[^a-zA-Z0-9_]/.test(str) // Non-alphanumeric except underscore
+        : /^[^a-zA-Z0-9]/.test(str); // Non-alphanumeric including underscore
+    let isFirstMatch = true;
+    // Determine delimiter pattern based on retainUnderscores
+    const delimiterPattern = retainUnderscores
+        ? /[^a-zA-Z0-9_]+([a-zA-Z0-9_]+)/g // Treat underscore as regular character
+        : /[^a-zA-Z0-9]+([a-zA-Z0-9]+)/g; // Treat underscore as delimiter
+    const camelCased = str.replace(delimiterPattern, (_, matched) => {
+        // If string starts with delimiter and this is the first match:
+        // - Capitalize only if upperFirst is true
+        // Otherwise, always capitalize (word comes after delimiter)
+        if (isFirstMatch && startsWithDelimiter && !upperFirst) {
+            isFirstMatch = false;
+            return matched;
         }
-        doCapitalize = true;
-        return matched;
+        isFirstMatch = false;
+        return capitalize(matched);
     });
-    const cleaned = camelCased.replaceAll(/[^a-z0-9]*/gi, '');
+    // Clean non-alphanumeric characters (preserving underscores if retainUnderscores)
+    const cleanPattern = retainUnderscores ? /[^a-zA-Z0-9_]/g : /[^a-zA-Z0-9]/g;
+    const cleaned = camelCased.replace(cleanPattern, '');
     return upperFirst ? capitalize(cleaned) : cleaned;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skmtc/core",
-  "version": "0.0.828",
+  "version": "0.0.829",
   "description": "Skmtc is a declarative code generation framework",
   "keywords": [
     "openapi",

package/script/helpers/strings.d.ts

@@ -77,6 +77,8 @@ export declare const decapitalize: (str: string) => string;
 type CamelCaseOptions = {
     /** Whether to capitalize the first character (PascalCase) */
     upperFirst?: boolean;
+    /** Whether to retain underscores in place when converting strings */
+    retainUnderscores?: boolean;
 };
 /**
  * Converts a string to camelCase, removing non-alphanumeric characters.
@@ -88,6 +90,7 @@ type CamelCaseOptions = {
  * @param str - The string to convert to camelCase
  * @param options - Options to control the conversion
  * @param options.upperFirst - Whether to capitalize the first character (default: false)
+ * @param options.retainUnderscores - Whether to retain underscores in place (default: false)
  * @returns The camelCase version of the input string
  *
  * @example Basic usage
@@ -110,7 +113,15 @@ type CamelCaseOptions = {
  * camelCase('XML_HTTP_Request'); // 'xmlHttpRequest'
  * camelCase('2fa-enabled'); // '2faEnabled'
  * ```
+ *
+ * @example Retaining underscores (retainUnderscores)
+ * ```typescript
+ * camelCase('user_name', { retainUnderscores: true }); // 'user_name'
+ * camelCase('api-key_token', { retainUnderscores: true }); // 'apiKey_token'
+ * camelCase('get_user_by_id', { retainUnderscores: true }); // 'get_user_by_id'
+ * camelCase('user_profile', { upperFirst: true, retainUnderscores: true }); // 'User_profile'
+ * ```
  */
-export declare const camelCase: (str: string, { upperFirst }?: CamelCaseOptions) => string;
+export declare const camelCase: (str: string, { upperFirst, retainUnderscores }?: CamelCaseOptions) => string;
 export {};
 //# sourceMappingURL=strings.d.ts.map

package/script/helpers/strings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,iBAAgB,gBAAqB,KAAG,MAgB9E,CAAA"}
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,oCAAmC,gBAAqB,KAAG,MA+BjG,CAAA"}

package/script/helpers/strings.js

@@ -90,6 +90,7 @@ exports.decapitalize = decapitalize;
  * @param str - The string to convert to camelCase
  * @param options - Options to control the conversion
  * @param options.upperFirst - Whether to capitalize the first character (default: false)
+ * @param options.retainUnderscores - Whether to retain underscores in place (default: false)
  * @returns The camelCase version of the input string
  *
  * @example Basic usage
@@ -112,17 +113,39 @@ exports.decapitalize = decapitalize;
  * camelCase('XML_HTTP_Request'); // 'xmlHttpRequest'
  * camelCase('2fa-enabled'); // '2faEnabled'
  * ```
+ *
+ * @example Retaining underscores (retainUnderscores)
+ * ```typescript
+ * camelCase('user_name', { retainUnderscores: true }); // 'user_name'
+ * camelCase('api-key_token', { retainUnderscores: true }); // 'apiKey_token'
+ * camelCase('get_user_by_id', { retainUnderscores: true }); // 'get_user_by_id'
+ * camelCase('user_profile', { upperFirst: true, retainUnderscores: true }); // 'User_profile'
+ * ```
  */
-const camelCase = (str, { upperFirst } = {}) => {
-    let doCapitalize = Boolean(upperFirst);
-    const camelCased = str.replace(/[^a-zA-Z0-9]+([a-zA-Z0-9]+)/g, (_, matched) => {
-        if (doCapitalize) {
-            return (0, exports.capitalize)(matched);
+const camelCase = (str, { upperFirst, retainUnderscores } = {}) => {
+    // Check if string starts with a delimiter
+    const startsWithDelimiter = retainUnderscores
+        ? /^[^a-zA-Z0-9_]/.test(str) // Non-alphanumeric except underscore
+        : /^[^a-zA-Z0-9]/.test(str); // Non-alphanumeric including underscore
+    let isFirstMatch = true;
+    // Determine delimiter pattern based on retainUnderscores
+    const delimiterPattern = retainUnderscores
+        ? /[^a-zA-Z0-9_]+([a-zA-Z0-9_]+)/g // Treat underscore as regular character
+        : /[^a-zA-Z0-9]+([a-zA-Z0-9]+)/g; // Treat underscore as delimiter
+    const camelCased = str.replace(delimiterPattern, (_, matched) => {
+        // If string starts with delimiter and this is the first match:
+        // - Capitalize only if upperFirst is true
+        // Otherwise, always capitalize (word comes after delimiter)
+        if (isFirstMatch && startsWithDelimiter && !upperFirst) {
+            isFirstMatch = false;
+            return matched;
         }
-        doCapitalize = true;
-        return matched;
+        isFirstMatch = false;
+        return (0, exports.capitalize)(matched);
     });
-    const cleaned = camelCased.replaceAll(/[^a-z0-9]*/gi, '');
+    // Clean non-alphanumeric characters (preserving underscores if retainUnderscores)
+    const cleanPattern = retainUnderscores ? /[^a-zA-Z0-9_]/g : /[^a-zA-Z0-9]/g;
+    const cleaned = camelCased.replace(cleanPattern, '');
     return upperFirst ? (0, exports.capitalize)(cleaned) : cleaned;
 };
 exports.camelCase = camelCase;