@bariskuran/base 0.0.0-stage → 0.0.2

package/src/libs/isArrayOrPlainObject/_dS.jsx

@@ -0,0 +1,75 @@
+import Ds from "../DesignSystem";
+import { SYS } from "../../constants/SYS";
+import { isArrayOrPlainObject } from ".";
+import { Flex } from "../Flex";
+import { Button } from "../Button";
+
+const X = () => {
+    const { outputButtonProps, Output } = Ds.useOutputViewer();
+
+    return (
+        <Ds.page
+            title="isArrayOrPlainObject()"
+            releasedOn="1.0.0"
+            description={{ tr: "Dizi veya düz nesneyi kontrol eder.", en: "Checks an array or plain object." }}
+        >
+            <Ds.block
+                title={{ tr: "Temel kullanım", en: "Basic Usage" }}
+                code={`import { isArrayOrPlainObject } from "${SYS.basePath}";
+
+                        isArrayOrPlainObject([]);
+                        isArrayOrPlainObject({});
+                        isArrayOrPlainObject(new Date());`}
+                example={
+                    <Flex.column gap={10} padding={10} full>
+                        <Flex gap={10} wrap>
+                            <Button.plain
+                                label="([])"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but1",
+                                    fn: () => isArrayOrPlainObject([]),
+                                })}
+                            />
+                            <Button.plain
+                                label="({})"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but2",
+                                    fn: () => isArrayOrPlainObject({}),
+                                })}
+                            />
+                            <Button.plain
+                                label="(new Date())"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but3",
+                                    fn: () => isArrayOrPlainObject(new Date()),
+                                })}
+                            />
+                        </Flex>
+                        <Output path="basic" />
+                    </Flex.column>
+                }
+            />
+            <Ds.api
+                args="const ok = isArrayOrPlainObject(v);"
+                props={{
+                    v: {
+                        description: { tr: "Test edilecek değer.", en: "Value to test." },
+                        type: "any",
+                        required: true,
+                    },
+                }}
+                returnProps={{
+                    ok: {
+                        description: { tr: "v null olmayan dizi veya düz nesneyse true.", en: "True if v is a non-null array or plain object." },
+                        type: "boolean",
+                    },
+                }}
+            />
+        </Ds.page>
+    );
+};
+
+export default X;

package/src/libs/isArrayOrPlainObject/index.js

@@ -0,0 +1,4 @@
+import { isArray } from "../isArray";
+import { isPlainObject } from "../isPlainObject";
+
+export const isArrayOrPlainObject = (v) => isArray(v) || isPlainObject(v);

package/src/libs/isDeepEqual/_dS.jsx

@@ -0,0 +1,343 @@
+import Ds from "../DesignSystem";
+import { SYS } from "../../constants/SYS";
+import { isDeepEqual } from ".";
+import { Flex } from "../Flex";
+import { Button } from "../Button";
+
+const X = () => {
+    const { outputButtonProps, Output } = Ds.useOutputViewer();
+
+    return (
+        <Ds.page
+            title="isDeepEqual()"
+            releasedOn="1.0.0"
+            description="Deep equality for objects, arrays, and primitives. Optional comparePath limits comparison to one dot path (byPath); only that slice is compared deeply."
+        >
+            <Ds.block
+                title="Basic usage"
+                code={`import { isDeepEqual } from "${SYS.basePath}";
+
+                        isDeepEqual({ a: 1 }, { a: 1 });
+                        isDeepEqual([1, 2], [2, 1]);`}
+                example={
+                    <Flex.column gap={10} padding={10} full>
+                        <Flex gap={10} wrap>
+                            <Button.plain
+                                label="({ a: 1 }, { a: 1 })"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but1",
+                                    fn: () => isDeepEqual({ a: 1 }, { a: 1 }),
+                                })}
+                            />
+                            <Button.plain
+                                label="([1, 2], [2, 1])"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but2",
+                                    fn: () => isDeepEqual([1, 2], [2, 1]),
+                                })}
+                            />
+                        </Flex>
+                        <Output path="basic" />
+                    </Flex.column>
+                }
+            />
+            <Ds.block
+                title="Advanced nested usage"
+                code={`import { isDeepEqual } from "${SYS.basePath}";
+
+                        isDeepEqual(
+                            {a:1, b:{ c:{d:2, e:[1,2,3]}}},
+                            {a:1, b:{ c:{d:2, e:[1,2,3]}}}
+                        );
+                        isDeepEqual(
+                            {a:1, b:{ c:{d:2, e:[1,2,3]}}},
+                            {a:1, b:{ c:{d:2, e:[1,2,3,4]}}}
+                        );`}
+                example={
+                    <Flex.column gap={10} padding={10} full>
+                        <Flex gap={10} wrap>
+                            <Button.plain
+                                label="nested equal"
+                                {...outputButtonProps({
+                                    path: "adv",
+                                    activeLabel: "but1",
+                                    fn: () =>
+                                        isDeepEqual(
+                                            { a: 1, b: { c: { d: 2, e: [1, 2, 3] } } },
+                                            { a: 1, b: { c: { d: 2, e: [1, 2, 3] } } },
+                                        ),
+                                })}
+                            />
+                            <Button.plain
+                                label="nested non-equal"
+                                {...outputButtonProps({
+                                    path: "adv",
+                                    activeLabel: "but2",
+                                    fn: () =>
+                                        isDeepEqual(
+                                            { a: 1, b: { c: { d: 2, e: [1, 2, 3] } } },
+                                            { a: 1, b: { c: { d: 2, e: [1, 2, 3, 4] } } },
+                                        ),
+                                })}
+                            />
+                        </Flex>
+                        <Output path="adv" />
+                    </Flex.column>
+                }
+            />
+            <Ds.block
+                title="Falsies values"
+                description="Treats falsy values as equal when treatFalsiesAsEqual is true."
+                code={`import { isDeepEqual } from "${SYS.basePath}";
+
+                        isDeepEqual({ a: undefined }, { a: false }); // this will return false. Others are equal.
+                        isDeepEqual({ a: undefined }, { a: false }, { treatFalsiesAsEqual: true });
+                        isDeepEqual({ a: undefined }, { a: null }, { treatFalsiesAsEqual: true });
+                        isDeepEqual({ a: undefined }, { a: 0 }, { treatFalsiesAsEqual: true });
+`}
+                example={
+                    <Flex.column gap={10} padding={10} full>
+                        <Flex gap={10} wrap>
+                            <Button.plain
+                                label="treatFalsiesAsEqual: false"
+                                {...outputButtonProps({
+                                    path: "fal",
+                                    activeLabel: "but0",
+                                    fn: () => isDeepEqual({ a: undefined }, { a: false }),
+                                })}
+                            />
+                            <Button.plain
+                                label="undefined vs false"
+                                {...outputButtonProps({
+                                    path: "fal",
+                                    activeLabel: "but1",
+                                    fn: () =>
+                                        isDeepEqual(
+                                            { a: undefined },
+                                            { a: false },
+                                            { treatFalsiesAsEqual: true },
+                                        ),
+                                })}
+                            />
+                            <Button.plain
+                                label="undefined vs null"
+                                {...outputButtonProps({
+                                    path: "fal",
+                                    activeLabel: "but2",
+                                    fn: () =>
+                                        isDeepEqual(
+                                            { a: undefined },
+                                            { a: null },
+                                            { treatFalsiesAsEqual: true },
+                                        ),
+                                })}
+                            />
+                            <Button.plain
+                                label="undefined vs 0"
+                                {...outputButtonProps({
+                                    path: "fal",
+                                    activeLabel: "but3",
+                                    fn: () =>
+                                        isDeepEqual(
+                                            { a: undefined },
+                                            { a: 0 },
+                                            { treatFalsiesAsEqual: true },
+                                        ),
+                                })}
+                            />
+                        </Flex>
+                        <Output path="fal" />
+                    </Flex.column>
+                }
+            />
+            <Ds.block
+                title="comparePath"
+                description="Limits comparison to one dot path (byPath); only that slice is compared deeply."
+                code={`import { isDeepEqual } from "${SYS.basePath}";
+
+                        isDeepEqual(
+                            { a: 1, b: { c: 2 }},
+                            { a: 2, b: { c: 2 }}
+                        );
+                        isDeepEqual(
+                            { a: 1, b: { c: 2 }},
+                            { a: 2, b: { c: 2 }},
+                            { comparePath: "b.c"},
+                        );
+                        isDeepEqual(
+                            { wrap: { id: 1, n: 1 } },
+                            { wrap: { id: 1, n: 9 } },
+                            { comparePath: "wrap" },
+                        );
+                        isDeepEqual(
+                            { wrap: { id: 1, tag: "x" } },
+                            { wrap: { id: 1, tag: "x" } },
+                            { comparePath: "wrap.tag" },
+                        );`}
+                example={
+                    <Flex.column gap={10} padding={10} full>
+                        <Flex gap={10} wrap>
+                            <Button.plain
+                                label="Full object → false (a differs)"
+                                {...outputButtonProps({
+                                    path: "cp",
+                                    activeLabel: "but1",
+                                    fn: () =>
+                                        isDeepEqual({ a: 1, b: { c: 2 } }, { a: 2, b: { c: 2 } }),
+                                })}
+                            />
+                            <Button.plain
+                                label="comparePath b.c → true"
+                                {...outputButtonProps({
+                                    path: "cp",
+                                    activeLabel: "but2",
+                                    fn: () =>
+                                        isDeepEqual(
+                                            { a: 1, b: { c: 2 } },
+                                            { a: 2, b: { c: 2 } },
+                                            { comparePath: "b.c" },
+                                        ),
+                                })}
+                            />
+                            <Button.plain
+                                label="comparePath wrap → false (n differs)"
+                                {...outputButtonProps({
+                                    path: "cp",
+                                    activeLabel: "but3",
+                                    fn: () =>
+                                        isDeepEqual(
+                                            { wrap: { id: 1, n: 1 } },
+                                            { wrap: { id: 1, n: 9 } },
+                                            { comparePath: "wrap" },
+                                        ),
+                                })}
+                            />
+                            <Button.plain
+                                label="comparePath wrap.tag → true"
+                                {...outputButtonProps({
+                                    path: "cp",
+                                    activeLabel: "but4",
+                                    fn: () =>
+                                        isDeepEqual(
+                                            { wrap: { id: 1, tag: "x" } },
+                                            { wrap: { id: 1, tag: "x" } },
+                                            { comparePath: "wrap.tag" },
+                                        ),
+                                })}
+                            />
+                        </Flex>
+                        <Output path="cp" />
+                    </Flex.column>
+                }
+            />
+            <Ds.block
+                title="ignoreArrayOrder"
+                description="Treats arrays as multisets (same length, each item paired exactly once by deep equality; order ignored)."
+                code={`import { isDeepEqual } from "${SYS.basePath}";
+
+                        isDeepEqual(
+                            [1, 2],
+                            [2, 1]
+                        );
+                        isDeepEqual(
+                            [1, 2],
+                            [2, 1],
+                            { ignoreArrayOrder: true },
+                        );
+                        isDeepEqual(
+                            [{ x: 1 }, { x: 2 }],
+                            [{ x: 2 }, { x: 1 }],
+                            { ignoreArrayOrder: true },
+                        );`}
+                example={
+                    <Flex.column gap={10} padding={10} full>
+                        <Flex gap={10} wrap>
+                            <Button.plain
+                                label="ignoreArrayOrder → false"
+                                {...outputButtonProps({
+                                    path: "ord",
+                                    activeLabel: "but1",
+                                    fn: () => isDeepEqual([1, 2], [2, 1]),
+                                })}
+                            />
+                            <Button.plain
+                                label="ignoreArrayOrder → true"
+                                {...outputButtonProps({
+                                    path: "ord",
+                                    activeLabel: "but2",
+                                    fn: () =>
+                                        isDeepEqual([1, 2], [2, 1], { ignoreArrayOrder: true }),
+                                })}
+                            />
+                            <Button.plain
+                                label="Nested objects, reversed order"
+                                {...outputButtonProps({
+                                    path: "ord",
+                                    activeLabel: "but3",
+                                    fn: () =>
+                                        isDeepEqual([{ x: 1 }, { x: 2 }], [{ x: 2 }, { x: 1 }], {
+                                            ignoreArrayOrder: true,
+                                        }),
+                                })}
+                            />
+                        </Flex>
+                        <Output path="ord" />
+                    </Flex.column>
+                }
+            />
+            <Ds.api
+                args={[
+                    "const equal = isDeepEqual(value1, value2, { comparePath, ignoreArrayOrder, maxDepth, maxKeys, treatFalsiesAsEqual });",
+                ]}
+                props={{
+                    value1: {
+                        description: "First value.",
+                        type: "any",
+                        required: true,
+                    },
+                    value2: {
+                        description: "Second value.",
+                        type: "any",
+                        required: true,
+                    },
+                    treatFalsiesAsEqual: {
+                        description: "Treats falsy values as equal in comparisons.",
+                        type: "boolean",
+                        defaultValue: "false",
+                    },
+                    maxKeys: {
+                        description: "Maximum key count guard for deep checks.",
+                        type: "number",
+                        defaultValue: "500",
+                    },
+                    maxDepth: {
+                        description: "Maximum recursion depth for deep checks.",
+                        type: "number",
+                        defaultValue: "10",
+                    },
+                    comparePath: {
+                        description:
+                            "Non-empty dot path (same rules as byPath.get). When set, only the values at that path in both roots are compared deeply; all other properties are ignored. To compare a field literally named `hash`, include it in the path (e.g. `wrap.hash`).",
+                        type: "string",
+                    },
+                    ignoreArrayOrder: {
+                        description:
+                            "When true, arrays are equal if lengths match and elements form the same multiset (each item pairs once by deep equality; order ignored). Nested arrays use the same rule.",
+                        type: "boolean",
+                        defaultValue: "false",
+                    },
+                }}
+                returnProps={{
+                    equal: {
+                        description: "True when both values are deeply equal under the given options.",
+                        type: "boolean",
+                    },
+                }}
+            />
+        </Ds.page>
+    );
+};
+
+export default X;

package/src/libs/isDeepEqual/index.js

@@ -0,0 +1,83 @@
+import { typeOf } from "../typeOf";
+import { byPath } from "../byPath";
+
+const DEFAULTS = {
+    treatFalsiesAsEqual: false,
+    maxKeys: 500,
+    maxDepth: 10,
+    ignoreArrayOrder: false,
+};
+
+const arraysEqualIgnoreOrder = (a, b, opts, level, seen) => {
+    const used = new Uint8Array(b.length);
+    outer: for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < b.length; j++) {
+            if (used[j]) continue;
+            if (isDeepEqual(a[i], b[j], opts, level + 1, seen)) {
+                used[j] = 1;
+                continue outer;
+            }
+        }
+        return false;
+    }
+    return true;
+};
+
+export const isDeepEqual = (a, b, settings = {}, level = 0, seen) => {
+    const opts = { ...DEFAULTS, ...(settings || {}) };
+
+    if (level > opts.maxDepth) return false;
+
+    if (level === 0 && typeof opts.comparePath === "string" && opts.comparePath.trim() !== "") {
+        const p = opts.comparePath.trim();
+        const va = byPath.get(a, p);
+        const vb = byPath.get(b, p);
+        const { comparePath: _comparePath, ...rest } = opts;
+        return isDeepEqual(va, vb, rest, level, seen);
+    }
+
+    if (Object.is(a, b)) return true;
+
+    if (opts.treatFalsiesAsEqual) {
+        if (!a && !b) return true;
+    }
+
+    const t1 = typeOf(a);
+    const t2 = typeOf(b);
+    if (t1 !== t2) return false;
+    if (t1 === "date") return a.getTime() === b.getTime();
+    if (t1 === "regexp") return a.source === b.source && a.flags === b.flags;
+    if (t1 === "function") return a.toString() === b.toString();
+    if (t1 !== "object" && t1 !== "array") return false;
+    if (a && b && typeof a === "object" && typeof b === "object") {
+        if (!seen) seen = new WeakMap();
+        const cached = seen.get(a);
+        if (cached && cached === b) return true;
+        seen.set(a, b);
+    }
+    if (a instanceof Date) return b instanceof Date && a.getTime() === b.getTime();
+    if (a instanceof RegExp)
+        return b instanceof RegExp && a.source === b.source && a.flags === b.flags;
+    if (t1 === "array") {
+        if (a.length !== b.length) return false;
+        if (a.length > opts.maxKeys) return false;
+        if (opts.ignoreArrayOrder) return arraysEqualIgnoreOrder(a, b, opts, level, seen);
+        for (let i = 0; i < a.length; i++) {
+            if (!isDeepEqual(a[i], b[i], opts, level + 1, seen)) return false;
+        }
+        return true;
+    }
+
+    const keysA = Object.keys(a || {});
+    const keysB = Object.keys(b || {});
+    if (keysA.length !== keysB.length) return false;
+
+    if (keysA.length > opts.maxKeys) return false;
+
+    for (const k of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+        if (!isDeepEqual(a[k], b[k], opts, level + 1, seen)) return false;
+    }
+
+    return true;
+};

package/src/libs/isNumber/_dS.jsx

@@ -0,0 +1,71 @@
+import Ds from "../DesignSystem";
+import { SYS } from "../../constants/SYS";
+import { isNumber } from ".";
+import { Flex } from "../Flex";
+import { Button } from "../Button";
+
+const X = () => {
+    const { outputButtonProps, Output } = Ds.useOutputViewer();
+
+    return (
+        <Ds.page title="isNumber()" releasedOn="1.0.0" description={{ tr: "Sonlu sayısal değerleri kontrol eder.", en: "Checks finite numeric values." }}>
+            <Ds.block
+                title={{ tr: "Temel kullanım", en: "Basic Usage" }}
+                code={`import { isNumber } from "${SYS.basePath}";
+
+                        isNumber(12);
+                        isNumber("12.4");
+                        isNumber("abc");`}
+                example={
+                    <Flex.column gap={10} padding={10} full>
+                        <Flex gap={10} wrap>
+                            <Button.plain
+                                label="isNumber(12)"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but1",
+                                    fn: () => isNumber(12),
+                                })}
+                            />
+                            <Button.plain
+                                label='isNumber("12.4")'
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but2",
+                                    fn: () => isNumber("12.4"),
+                                })}
+                            />
+                            <Button.plain
+                                label='isNumber("abc")'
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but3",
+                                    fn: () => isNumber("abc"),
+                                })}
+                            />
+                        </Flex>
+                        <Output path="basic" />
+                    </Flex.column>
+                }
+            />
+            <Ds.api
+                args="const ok = isNumber(data);"
+                props={{
+                    data: {
+                        description: { tr: "Kontrol edilecek değer.", en: "Value to check." },
+                        type: "any",
+                        required: true,
+                    },
+                }}
+                returnProps={{
+                    ok: {
+                        description: { tr: "Sonlu, sayısal benzeri değerlerde true.", en: "True for finite numeric-like values." },
+                        type: "boolean",
+                    },
+                }}
+            />
+        </Ds.page>
+    );
+};
+
+export default X;

package/src/libs/isNumber/index.js

@@ -0,0 +1 @@
+export const isNumber = (data) => !isNaN(parseFloat(data)) && isFinite(data);

package/src/libs/isPlainObject/_dS.jsx

@@ -0,0 +1,75 @@
+import Ds from "../DesignSystem";
+import { SYS } from "../../constants/SYS";
+import { isPlainObject } from ".";
+import { Flex } from "../Flex";
+import { Button } from "../Button";
+
+const X = () => {
+    const { outputButtonProps, Output } = Ds.useOutputViewer();
+
+    return (
+        <Ds.page
+            title="isPlainObject()"
+            releasedOn="1.0.0"
+            description={{ tr: "Düz nesne değerlerini kontrol eder.", en: "Checks plain-object values." }}
+        >
+            <Ds.block
+                title={{ tr: "Temel kullanım", en: "Basic Usage" }}
+                code={`import { isPlainObject } from "${SYS.basePath}";
+
+                        isPlainObject({ a: 1 });
+
+                        isPlainObject(new Date());`}
+                example={
+                    <Flex.column gap={10} padding={10} full>
+                        <Flex gap={10} wrap>
+                            <Button.plain
+                                label="isPlainObject({})"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but1",
+                                    fn: () => isPlainObject({}),
+                                })}
+                            />
+                            <Button.plain
+                                label="isPlainObject(new Date())"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but2",
+                                    fn: () => isPlainObject(new Date()),
+                                })}
+                            />
+                            <Button.plain
+                                label="isPlainObject([])"
+                                {...outputButtonProps({
+                                    path: "basic",
+                                    activeLabel: "but3",
+                                    fn: () => isPlainObject([]),
+                                })}
+                            />
+                        </Flex>
+                        <Output path="basic" />
+                    </Flex.column>
+                }
+            />
+            <Ds.api
+                args="const ok = isPlainObject(v);"
+                props={{
+                    v: {
+                        description: { tr: "Test edilecek değer.", en: "Value to test." },
+                        type: "any",
+                        required: true,
+                    },
+                }}
+                returnProps={{
+                    ok: {
+                        description: { tr: "Düz nesne veya null-prototype nesnesinde true.", en: "True for a plain object or null-prototype object." },
+                        type: "boolean",
+                    },
+                }}
+            />
+        </Ds.page>
+    );
+};
+
+export default X;

package/src/libs/isPlainObject/index.js

@@ -0,0 +1,7 @@
+import { typeOf } from "../typeOf";
+
+export const isPlainObject = (v) => {
+    if (typeOf(v) !== "object") return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+};