utilitish 0.0.18 → 0.0.20

package/dist/utils/logic.utils.spec.js

@@ -1,56 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const logic_utils_1 = require("./logic.utils");
+import { sortBy } from './logic.utils';
 describe('logic.utils', () => {
     describe('sortBy()', () => {
         describe('with primitive arrays', () => {
             it('should sort numbers in ascending order', () => {
-                expect((0, logic_utils_1.sortBy)([3, 1, 2], 'asc')).toEqual([1, 2, 3]);
+                expect(sortBy([3, 1, 2], 'asc')).toEqual([1, 2, 3]);
             });
             it('should sort numbers in descending order', () => {
-                expect((0, logic_utils_1.sortBy)([1, 3, 2], 'desc')).toEqual([3, 2, 1]);
+                expect(sortBy([1, 3, 2], 'desc')).toEqual([3, 2, 1]);
             });
             it('should sort strings in ascending order', () => {
-                expect((0, logic_utils_1.sortBy)(['b', 'a', 'c'], 'asc')).toEqual(['a', 'b', 'c']);
+                expect(sortBy(['b', 'a', 'c'], 'asc')).toEqual(['a', 'b', 'c']);
             });
             it('should sort strings in descending order', () => {
-                expect((0, logic_utils_1.sortBy)(['b', 'a', 'c'], 'desc')).toEqual(['c', 'b', 'a']);
+                expect(sortBy(['b', 'a', 'c'], 'desc')).toEqual(['c', 'b', 'a']);
             });
             it('should return empty array when input is empty', () => {
-                expect((0, logic_utils_1.sortBy)([], 'asc')).toEqual([]);
+                expect(sortBy([], 'asc')).toEqual([]);
             });
             it('should not mutate the original array', () => {
                 const arr = [3, 1, 2];
-                (0, logic_utils_1.sortBy)(arr, 'asc');
+                sortBy(arr, 'asc');
                 expect(arr).toEqual([3, 1, 2]);
             });
         });
         describe('with selector function', () => {
             it('should sort in ascending order using selector', () => {
                 const arr = [{ v: 3 }, { v: 1 }, { v: 2 }];
-                expect((0, logic_utils_1.sortBy)(arr, 'asc', (x) => x.v)).toEqual([{ v: 1 }, { v: 2 }, { v: 3 }]);
+                expect(sortBy(arr, 'asc', (x) => x.v)).toEqual([{ v: 1 }, { v: 2 }, { v: 3 }]);
             });
             it('should sort in descending order using selector', () => {
                 const arr = [{ v: 1 }, { v: 3 }, { v: 2 }];
-                expect((0, logic_utils_1.sortBy)(arr, 'desc', (x) => x.v)).toEqual([{ v: 3 }, { v: 2 }, { v: 1 }]);
+                expect(sortBy(arr, 'desc', (x) => x.v)).toEqual([{ v: 3 }, { v: 2 }, { v: 1 }]);
             });
         });
         describe('with selector string key', () => {
             it('should sort in ascending order using property key', () => {
                 const arr = [{ v: 3 }, { v: 1 }, { v: 2 }];
-                expect((0, logic_utils_1.sortBy)(arr, 'asc', 'v')).toEqual([{ v: 1 }, { v: 2 }, { v: 3 }]);
+                expect(sortBy(arr, 'asc', 'v')).toEqual([{ v: 1 }, { v: 2 }, { v: 3 }]);
             });
             it('should sort in descending order using property key', () => {
                 const arr = [{ v: 1 }, { v: 3 }, { v: 2 }];
-                expect((0, logic_utils_1.sortBy)(arr, 'desc', 'v')).toEqual([{ v: 3 }, { v: 2 }, { v: 1 }]);
+                expect(sortBy(arr, 'desc', 'v')).toEqual([{ v: 3 }, { v: 2 }, { v: 1 }]);
             });
         });
         describe('error handling', () => {
             it('should throw TypeError when elements are not sortable without selector', () => {
-                expect(() => (0, logic_utils_1.sortBy)([{ v: 1 }], 'asc')).toThrow(TypeError);
+                expect(() => sortBy([{ v: 1 }], 'asc')).toThrow(TypeError);
             });
             it('should throw TypeError when selector returns non-sortable value', () => {
-                expect(() => (0, logic_utils_1.sortBy)([{ v: {} }], 'asc', (x) => x.v)).toThrow(TypeError);
+                expect(() => sortBy([{ v: {} }], 'asc', (x) => x.v)).toThrow(TypeError);
             });
         });
     });

package/dist/utils/slugify.config.js

@@ -1,18 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlugifyConfigBuilder = exports.SlugifyConfig = void 0;
-exports.getDefaultSlugifyConfig = getDefaultSlugifyConfig;
-exports.assertCharClass = assertCharClass;
-exports.assertSlugifyConfig = assertSlugifyConfig;
-exports.setSlugifyConfig = setSlugifyConfig;
-exports.getSlugifyConfig = getSlugifyConfig;
-exports.resetSlugifyConfig = resetSlugifyConfig;
-exports.slugifyString = slugifyString;
 /**
  * Configuration class for the slugify functionality.
  * Provides comprehensive customization options for URL slug generation.
  */
-class SlugifyConfig {
+export class SlugifyConfig {
     constructor(builder) {
         this._customReplacements = builder.customReplacements;
         this._separator = builder.separator;
@@ -142,8 +132,7 @@ class SlugifyConfig {
         return config.slugify(str);
     }
 }
-exports.SlugifyConfig = SlugifyConfig;
-class SlugifyConfigBuilder {
+export class SlugifyConfigBuilder {
     constructor() {
         this.customReplacements = {};
         this.separator = '-';
@@ -184,12 +173,11 @@ class SlugifyConfigBuilder {
         return config;
     }
 }
-exports.SlugifyConfigBuilder = SlugifyConfigBuilder;
 /**
  * Default configuration for slugify operations.
  * Provides sensible defaults that can be overridden by users.
  */
-function getDefaultSlugifyConfig() {
+export function getDefaultSlugifyConfig() {
     return SlugifyConfig.default();
 }
 /**
@@ -211,13 +199,13 @@ let globalSlugifyConfig = getDefaultSlugifyConfig();
  *     .build()
  * );
  */
-function assertCharClass(regex) {
+export function assertCharClass(regex) {
     const src = regex.source;
     if (!src.startsWith('[') || !src.endsWith(']')) {
         throw new Error(`Invalid allowedChars: must be a character class like /[a-z]/, received ${regex}`);
     }
 }
-function assertSlugifyConfig(builderOrConfig) {
+export function assertSlugifyConfig(builderOrConfig) {
     const allowedChars = builderOrConfig.allowedChars;
     const separator = builderOrConfig.separator;
     const caseValue = builderOrConfig.case;
@@ -252,7 +240,7 @@ function assertSlugifyConfig(builderOrConfig) {
         throw new TypeError(`Invalid transformers: expected an array of functions`);
     }
 }
-function setSlugifyConfig(config) {
+export function setSlugifyConfig(config) {
     globalSlugifyConfig = config;
 }
 /**
@@ -261,13 +249,13 @@ function setSlugifyConfig(config) {
  *
  * @returns Current global configuration object
  */
-function getSlugifyConfig() {
+export function getSlugifyConfig() {
     return globalSlugifyConfig;
 }
 /**
  * Resets the global slugify configuration to default values.
  */
-function resetSlugifyConfig() {
+export function resetSlugifyConfig() {
     globalSlugifyConfig = getDefaultSlugifyConfig();
 }
 /**
@@ -278,7 +266,7 @@ function resetSlugifyConfig() {
  * @param config - Configuration object (uses global config if not provided)
  * @returns The slugified string
  */
-function slugifyString(str, config) {
+export function slugifyString(str, config) {
     // Merge provided config with global config
     const globalConfig = getSlugifyConfig();
     const finalConfig = config ? globalConfig.merge(config) : globalConfig;

package/dist/utils/slugify.config.spec.js

@@ -1,60 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const slugify_config_1 = require("./slugify.config");
+import { SlugifyConfig, assertCharClass, assertSlugifyConfig, getDefaultSlugifyConfig, getSlugifyConfig, resetSlugifyConfig, setSlugifyConfig, } from './slugify.config';
 describe('slugify.config', () => {
     afterEach(() => {
-        (0, slugify_config_1.resetSlugifyConfig)();
+        resetSlugifyConfig();
     });
     describe('SlugifyConfig.default()', () => {
         it('should return a config with default separator', () => {
-            expect((0, slugify_config_1.getDefaultSlugifyConfig)().separator).toBe('-');
+            expect(getDefaultSlugifyConfig().separator).toBe('-');
         });
         it('should return a config with lowercase case', () => {
-            expect((0, slugify_config_1.getDefaultSlugifyConfig)().case).toBe('lower');
+            expect(getDefaultSlugifyConfig().case).toBe('lower');
         });
         it('should return a config with removeAccents enabled', () => {
-            expect((0, slugify_config_1.getDefaultSlugifyConfig)().removeAccents).toBe(true);
+            expect(getDefaultSlugifyConfig().removeAccents).toBe(true);
         });
     });
     describe('SlugifyConfig.slugify()', () => {
         describe('with default config', () => {
             it('should convert to lowercase', () => {
-                expect(slugify_config_1.SlugifyConfig.default().slugify('Hello World')).toBe('hello-world');
+                expect(SlugifyConfig.default().slugify('Hello World')).toBe('hello-world');
             });
             it('should replace spaces with separator', () => {
-                expect(slugify_config_1.SlugifyConfig.default().slugify('foo bar')).toBe('foo-bar');
+                expect(SlugifyConfig.default().slugify('foo bar')).toBe('foo-bar');
             });
             it('should remove accents', () => {
-                expect(slugify_config_1.SlugifyConfig.default().slugify('Héllo')).toBe('hello');
+                expect(SlugifyConfig.default().slugify('Héllo')).toBe('hello');
             });
             it('should collapse multiple separators', () => {
-                expect(slugify_config_1.SlugifyConfig.default().slugify('foo  bar')).toBe('foo-bar');
+                expect(SlugifyConfig.default().slugify('foo  bar')).toBe('foo-bar');
             });
             it('should trim leading and trailing separators', () => {
-                expect(slugify_config_1.SlugifyConfig.default().slugify(' foo ')).toBe('foo');
+                expect(SlugifyConfig.default().slugify(' foo ')).toBe('foo');
             });
         });
         describe('with custom separator', () => {
             it('should use custom separator', () => {
-                const config = slugify_config_1.SlugifyConfig.builder().withSeparator('_').build();
+                const config = SlugifyConfig.builder().withSeparator('_').build();
                 expect(config.slugify('hello world')).toBe('hello_world');
             });
         });
         describe('with maxLength', () => {
             it('should truncate to maxLength', () => {
-                const config = slugify_config_1.SlugifyConfig.builder().withMaxLength(5).build();
+                const config = SlugifyConfig.builder().withMaxLength(5).build();
                 expect(config.slugify('hello world').length).toBeLessThanOrEqual(5);
             });
         });
         describe('with custom replacements', () => {
             it('should apply custom replacements before slugifying', () => {
-                const config = slugify_config_1.SlugifyConfig.builder().withCustomReplacements({ '&': 'and' }).build();
+                const config = SlugifyConfig.builder().withCustomReplacements({ '&': 'and' }).build();
                 expect(config.slugify('cats & dogs')).toBe('cats-and-dogs');
             });
         });
         describe('with transformers', () => {
             it('should apply transformers before slugifying', () => {
-                const config = slugify_config_1.SlugifyConfig.builder()
+                const config = SlugifyConfig.builder()
                     .withTransformers([(s) => s.replace('foo', 'bar')])
                     .build();
                 expect(config.slugify('foo baz')).toBe('bar-baz');
@@ -63,82 +61,82 @@ describe('slugify.config', () => {
     });
     describe('SlugifyConfig.slugifyWith()', () => {
         it('should slugify with a temporary configuration', () => {
-            const result = slugify_config_1.SlugifyConfig.slugifyWith('hello world', (b) => b.withSeparator('_'));
+            const result = SlugifyConfig.slugifyWith('hello world', (b) => b.withSeparator('_'));
             expect(result).toBe('hello_world');
         });
     });
     describe('SlugifyConfig.merge()', () => {
         it('should merge two configs with the other taking precedence', () => {
-            const base = slugify_config_1.SlugifyConfig.builder().withSeparator('-').build();
-            const other = slugify_config_1.SlugifyConfig.builder().withSeparator('_').build();
+            const base = SlugifyConfig.builder().withSeparator('-').build();
+            const other = SlugifyConfig.builder().withSeparator('_').build();
             expect(base.merge(other).separator).toBe('_');
         });
     });
     describe('assertCharClass()', () => {
         it('should not throw for a valid character class', () => {
-            expect(() => (0, slugify_config_1.assertCharClass)(/[a-z]/)).not.toThrow();
+            expect(() => assertCharClass(/[a-z]/)).not.toThrow();
         });
         describe('error handling', () => {
             it('should throw Error for a regex that is not a character class', () => {
-                expect(() => (0, slugify_config_1.assertCharClass)(/a-z/)).toThrow(Error);
+                expect(() => assertCharClass(/a-z/)).toThrow(Error);
             });
         });
     });
     describe('assertSlugifyConfig()', () => {
         it('should not throw for a valid builder', () => {
-            expect(() => (0, slugify_config_1.assertSlugifyConfig)(slugify_config_1.SlugifyConfig.builder())).not.toThrow();
+            expect(() => assertSlugifyConfig(SlugifyConfig.builder())).not.toThrow();
         });
         describe('error handling', () => {
             it('should throw TypeError for invalid separator', () => {
-                const builder = slugify_config_1.SlugifyConfig.builder();
+                const builder = SlugifyConfig.builder();
                 builder.separator = 123;
-                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+                expect(() => assertSlugifyConfig(builder)).toThrow(TypeError);
             });
             it('should throw TypeError for invalid case value', () => {
-                const builder = slugify_config_1.SlugifyConfig.builder();
+                const builder = SlugifyConfig.builder();
                 builder.case = 'invalid';
-                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+                expect(() => assertSlugifyConfig(builder)).toThrow(TypeError);
             });
             it('should throw TypeError for invalid removeAccents', () => {
-                const builder = slugify_config_1.SlugifyConfig.builder();
+                const builder = SlugifyConfig.builder();
                 builder.removeAccents = 'yes';
-                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+                expect(() => assertSlugifyConfig(builder)).toThrow(TypeError);
             });
             it('should throw TypeError for invalid maxLength', () => {
-                const builder = slugify_config_1.SlugifyConfig.builder();
+                const builder = SlugifyConfig.builder();
                 builder.maxLength = -1;
-                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+                expect(() => assertSlugifyConfig(builder)).toThrow(TypeError);
             });
             it('should throw TypeError for invalid allowedChars', () => {
-                const builder = slugify_config_1.SlugifyConfig.builder();
+                const builder = SlugifyConfig.builder();
                 builder.allowedChars = 'not-a-regex';
-                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+                expect(() => assertSlugifyConfig(builder)).toThrow(TypeError);
             });
             it('should throw TypeError for invalid transformers', () => {
-                const builder = slugify_config_1.SlugifyConfig.builder();
+                const builder = SlugifyConfig.builder();
                 builder.transformers = ['not-a-function'];
-                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+                expect(() => assertSlugifyConfig(builder)).toThrow(TypeError);
             });
         });
     });
     describe('getSlugifyConfig()', () => {
         it('should return the default config initially', () => {
-            expect((0, slugify_config_1.getSlugifyConfig)().separator).toBe('-');
+            expect(getSlugifyConfig().separator).toBe('-');
         });
     });
     describe('setSlugifyConfig()', () => {
         it('should update the global config', () => {
-            const config = slugify_config_1.SlugifyConfig.builder().withSeparator('_').build();
-            (0, slugify_config_1.setSlugifyConfig)(config);
-            expect((0, slugify_config_1.getSlugifyConfig)().separator).toBe('_');
+            const config = SlugifyConfig.builder().withSeparator('_').build();
+            setSlugifyConfig(config);
+            expect(getSlugifyConfig().separator).toBe('_');
         });
     });
     describe('resetSlugifyConfig()', () => {
         it('should restore the default config', () => {
-            const config = slugify_config_1.SlugifyConfig.builder().withSeparator('_').build();
-            (0, slugify_config_1.setSlugifyConfig)(config);
-            (0, slugify_config_1.resetSlugifyConfig)();
-            expect((0, slugify_config_1.getSlugifyConfig)().separator).toBe('-');
+            const config = SlugifyConfig.builder().withSeparator('_').build();
+            setSlugifyConfig(config);
+            resetSlugifyConfig();
+            expect(getSlugifyConfig().separator).toBe('-');
         });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utilitish",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/FDonovan12/utilitish.git"
@@ -10,8 +10,15 @@
     "provenance": false
   },
   "description": "",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "files": [
     "dist"
   ],