mark-3 0.0.3 → 0.0.4

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.4](https://github.com/ismailceylan/mark-3/compare/v0.0.3...v0.0.4) (2025-08-02)
+
+
+### Features
+
+* **composables:** add new use-responsiveness composable ([3b6ebe4](https://github.com/ismailceylan/mark-3/commit/3b6ebe4f0c50668453071cf4146b3dc459a25f24))
+* **helpers:** add new types/is-map method ([fdcda02](https://github.com/ismailceylan/mark-3/commit/fdcda0239aab54951df1c708dee7e74989801c79))
+* **helpers:** add new types/is-set method ([618abbe](https://github.com/ismailceylan/mark-3/commit/618abbeb6f068774dfa4c6158302fd7ac5f7fccc))
+
+
+### Bug Fixes
+
+* **helpers:** ensures that the default argument value is used for chars on string/trim method ([645f41e](https://github.com/ismailceylan/mark-3/commit/645f41e883b8777a16e4773ed520411e9953a45b))
+
 ### [0.0.3](https://github.com/ismailceylan/mark-3/compare/v0.0.2...v0.0.3) (2025-08-02)
 
 

package/composables/index.js

@@ -1,2 +1,3 @@
-export { default as useEventListener } from "./use-event-listener.js";
 export { default as useMediaQuery } from "./use-media-query.js";
+export { default as useEventListener } from "./use-event-listener.js";
+export { default as useResponsiveness } from "./use-responsiveness.js";

package/composables/use-responsiveness.js

@@ -0,0 +1,61 @@
+import { reactive, toRefs } from "vue";
+import { camelToDash } from "../helpers/string";
+import { useMediaQuery } from ".";
+
+/**
+ * Reactive media query states for multiple breakpoints at once using
+ *   useMediaQuery composable under the hood and returns an object of
+ *   reactive media query states.
+ * 
+ * The object keys are the same as the keys of the rules object.
+ * 
+ * If the media queries you pass to the useResponsiveness composable
+ *   are min- prefixed, the relevant props of returned object will be
+ *   true if the screen is at least or more in that breakpoint. But if
+ *   the queries are min- and max- prefixed, the relevant props of the
+ *   reactive object that returned will be true if the screen is exactly
+ *   in that breakpoint.
+ * 
+ * You can pass any valid media query to the useResponsiveness composable
+ *   like color schemes, display modes, and more.
+ * 
+ * @typedef {import('vue').Ref} Ref
+ * @typedef {import('vue').Reactive} Reactive
+ * @param {Object} rules Object of media queries
+ * @returns {Reactive<{}>|Ref<boolean>} Object of reactive media query states
+ * @example
+ * const breakpoints = useResponsiveness({
+ *     mobile: "(max-width: 767px)",
+ *     tablet: "(min-width: 768px) and (max-width: 1023px)",
+ *     desktop: "(min-width: 1024px)",
+ * });
+ * // { mobile: false, tablet: false, desktop: true}
+ * // every property tells the screen is exactly in that breakpoint
+ * @example
+ * const breakpoints = useResponsiveness({
+ *     mobile: "(min-width: 300px)",
+ *     tablet: "(min-width: 768px)",
+ *     desktop: "(min-width: 1024px)",
+ * });
+ * // { mobile: true, tablet: true, desktop: false}
+ * // every property tells the screen is at least or more in that breakpoint
+ */
+export default function useResponsiveness( rules = {})
+{
+	const breakpoints = reactive({});
+	const keys = Object.keys( rules );
+
+	for( const name in rules )
+	{
+		useMediaQuery( rules[ name ], isActive =>
+			breakpoints[ camelToDash( name )] = isActive
+		);
+	}
+
+	if( keys.length === 1 )
+	{
+		return toRefs( breakpoints )[ keys[ 0 ]];
+	}
+
+	return breakpoints;
+}

package/helpers/string/escape-regex/index.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import escapeRegex from "./escapeRegex";
+import escapeRegex from ".";
 
 describe( "escapeRegex", () =>
 {

package/helpers/string/trim/index.js

@@ -11,7 +11,7 @@ import { isEmpty, isArray, isString } from "../../types";
  */
 export default function trim( input, chars = " " )
 {
-	if( ! isString( input ) || isEmpty( chars ))
+	if( ! isString( input ) || ( chars !== " " && isEmpty( chars )))
 	{
 		return input;
 	}

package/helpers/types/get-type-name/index.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import getTypeName from "./type";
+import getTypeName from ".";
 
 describe( "type", () =>
 {

package/helpers/types/index.js

@@ -1,3 +1,5 @@
+export { default as isMap } from "./is-map";
+export { default as isSet } from "./is-set";
 export { default as isArray } from "./is-array";
 export { default as isEmpty } from "./is-empty";
 export { default as isString } from "./is-string";

package/helpers/types/is-empty/index.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import isEmpty from "../src/isEmpty";
+import isEmpty from ".";
 
 describe( "isEmpty", () =>
 {

package/helpers/types/is-map/README.md

@@ -0,0 +1,15 @@
+# isMap
+Utility function to check if a value is a native `Map` object in JavaScript.
+
+---
+
+## Usage
+```js
+import { isMap } from "@mark-3/helpers/types";
+
+isMap(new Map());     // true
+isMap(new WeakMap()); // false
+isMap({});            // false
+isMap([]);            // false
+isMap(null);          // false
+```

package/helpers/types/is-map/index.js

@@ -0,0 +1,12 @@
+import { getTypeName } from "..";
+
+/**
+ * Checks if a given value is a Map.
+ *
+ * @param {any} value - The value to be checked.
+ * @returns {boolean} true if the value is a Map, false otherwise.
+ */
+export default function isMap( value )
+{
+	return getTypeName( value ) === "Map";
+}

package/helpers/types/is-map/index.test.js

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import isMap from ".";
+
+describe("isMap", () =>
+{
+	it("should return true for Map instances", () =>
+	{
+		expect(isMap(new Map())).toBe(true);
+		const map = new Map();
+		map.set("key", "value");
+		expect(isMap(map)).toBe(true);
+	});
+
+	it("should return false for WeakMap", () =>
+	{
+		expect(isMap(new WeakMap())).toBe(false);
+	});
+
+	it("should return false for plain objects", () =>
+	{
+		expect(isMap({})).toBe(false);
+		expect(isMap({ a: 1 })).toBe(false);
+	});
+
+	it("should return false for arrays", () =>
+	{
+		expect(isMap([])).toBe(false);
+		expect(isMap([1, 2, 3])).toBe(false);
+	});
+
+	it("should return false for other types", () =>
+	{
+		expect(isMap(null)).toBe(false);
+		expect(isMap(undefined)).toBe(false);
+		expect(isMap(42)).toBe(false);
+		expect(isMap("string")).toBe(false);
+		expect(isMap(true)).toBe(false);
+		expect(isMap(Symbol("sym"))).toBe(false);
+		expect(isMap(function () {})).toBe(false);
+	});
+});

package/helpers/types/is-plain-object/index.js

@@ -1,5 +1,3 @@
-import { getTypeName } from "../type";
-
 /**
  * Checks if the given value is a plain object.
  *
@@ -8,5 +6,12 @@ import { getTypeName } from "../type";
  */
 export default function isPlainObject( value )
 {
-	return getTypeName( value ) === "Object";
+	if( typeof value !== "object" || value === null )
+	{
+		return false;
+	}
+
+	const proto = Object.getPrototypeOf( value );
+	
+	return proto === Object.prototype || proto === null;
 }

package/helpers/types/is-plain-object/index.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import isPlainObject from "./isPlainObject";
+import isPlainObject from ".";
 
 describe("isPlainObject", () =>
 {

package/helpers/types/is-set/README.md

@@ -0,0 +1,15 @@
+# isSet
+Utility function to check if a value is a native `Set` object in JavaScript.
+
+---
+
+## Usage
+```js
+import { isSet } from "mark-3/helpers/types";
+
+isSet(new Set());     // true
+isSet(new WeakSet()); // false
+isSet({});            // false
+isSet([]);            // false
+isSet(null);          // false
+```

package/helpers/types/is-set/index.js

@@ -0,0 +1,12 @@
+import { getTypeName } from "..";
+
+/**
+ * Checks if a given value is a Set.
+ *
+ * @param {any} value - The value to be checked.
+ * @returns {boolean} true if the value is a Set, false otherwise.
+ */
+export default function isSet( value )
+{
+	return getTypeName( value ) === "Set";
+}

package/helpers/types/is-set/index.test.js

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import isSet from ".";
+
+describe("isSet", () =>
+{
+	it("should return true for Set instances", () =>
+	{
+		expect(isSet(new Set())).toBe(true);
+		const set = new Set();
+		set.add("key", "value");
+		expect(isSet(set)).toBe(true);
+	});
+
+	it("should return false for WeakSet", () =>
+	{
+		expect(isSet(new WeakSet())).toBe(false);
+	});
+
+	it("should return false for plain objects", () =>
+	{
+		expect(isSet({})).toBe(false);
+		expect(isSet({ a: 1 })).toBe(false);
+	});
+
+	it("should return false for arrays", () =>
+	{
+		expect(isSet([])).toBe(false);
+		expect(isSet([1, 2, 3])).toBe(false);
+	});
+
+	it("should return false for other types", () =>
+	{
+		expect(isSet(null)).toBe(false);
+		expect(isSet(undefined)).toBe(false);
+		expect(isSet(42)).toBe(false);
+		expect(isSet("string")).toBe(false);
+		expect(isSet(true)).toBe(false);
+		expect(isSet(Symbol("sym"))).toBe(false);
+		expect(isSet(function () {})).toBe(false);
+	});
+});

package/helpers/types/is-string/index.test.js

@@ -1,46 +1,46 @@
-import { describe, it, expect } from 'vitest';
-import isString from './isString'; // dosya yolunu kendi yapına göre düzenle
+import { describe, it, expect } from "vitest";
+import isString from ".";
 
-describe('isString', () => {
-  it('should return true for a normal string', () => {
-    expect(isString('hello')).toBe(true);
+describe("isString", () => {
+  it("should return true for a normal string", () => {
+    expect(isString("hello")).toBe(true);
   });
 
-  it('should return true for an empty string', () => {
-    expect(isString('')).toBe(true);
+  it("should return true for an empty string", () => {
+    expect(isString("")).toBe(true);
   });
 
-  it('should return false for a String object', () => {
-    // typeof new String('abc') === 'object'
-    expect(isString(new String('abc'))).toBe(false);
+  it("should return false for a String object", () => {
+    // typeof new String("abc") === "object"
+    expect(isString(new String("abc"))).toBe(false);
   });
 
-  it('should return false for a number', () => {
+  it("should return false for a number", () => {
     expect(isString(123)).toBe(false);
   });
 
-  it('should return false for null', () => {
+  it("should return false for null", () => {
     expect(isString(null)).toBe(false);
   });
 
-  it('should return false for undefined', () => {
+  it("should return false for undefined", () => {
     expect(isString(undefined)).toBe(false);
   });
 
-  it('should return false for an object', () => {
+  it("should return false for an object", () => {
     expect(isString({})).toBe(false);
   });
 
-  it('should return false for an array', () => {
-    expect(isString(['a', 'b'])).toBe(false);
+  it("should return false for an array", () => {
+    expect(isString(["a", "b"])).toBe(false);
   });
 
-  it('should return false for a boolean', () => {
+  it("should return false for a boolean", () => {
     expect(isString(true)).toBe(false);
     expect(isString(false)).toBe(false);
   });
 
-  it('should return false for a function', () => {
+  it("should return false for a function", () => {
     expect(isString(() => {})).toBe(false);
   });
 });

package/package.json

@@ -2,7 +2,7 @@
   "name": "mark-3",
   "description": "Modular collection of reusable JavaScript helpers, utilities, and Vue components. Built for maintainability, performance, and clarity.",
   "private": false,
-  "version": "0.0.3",
+  "version": "0.0.4",
   "workspaces": [
     "src/*/*"
   ],