@focus-reactive/payload-plugin-translator 0.1.0

package/dist/server/shared/utils/filterLocalizedFields.test.js

@@ -0,0 +1,338 @@
+import { describe, expect, it } from 'vitest';
+import { filterLocalizedFields } from './filterLocalizedFields';
+describe('filterLocalizedFields', () => {
+    describe('simple fields', () => {
+        it('should keep localized text field', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const data = { title: 'Hello', other: 'World' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({ title: 'Hello' });
+        });
+        it('should filter out non-localized text field', () => {
+            const schema = [{ name: 'slug', type: 'text' }];
+            const data = { slug: 'hello-world' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should handle mixed localized and non-localized fields', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'slug', type: 'text' },
+                { name: 'description', type: 'textarea', localized: true },
+            ];
+            const data = { title: 'Hello', slug: 'hello', description: 'World' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({ title: 'Hello', description: 'World' });
+        });
+        it('should skip undefined values', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const data = {};
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+    });
+    describe('group fields', () => {
+        it('should recursively filter group with localized nested field', () => {
+            const schema = [
+                {
+                    name: 'seo',
+                    type: 'group',
+                    fields: [
+                        { name: 'title', type: 'text', localized: true },
+                        { name: 'canonical', type: 'text' },
+                    ],
+                },
+            ];
+            const data = { seo: { title: 'SEO Title', canonical: '/page' } };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({ seo: { title: 'SEO Title' } });
+        });
+        it('should exclude group if no localized fields inside', () => {
+            const schema = [
+                {
+                    name: 'settings',
+                    type: 'group',
+                    fields: [{ name: 'enabled', type: 'checkbox' }],
+                },
+            ];
+            const data = { settings: { enabled: true } };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+    });
+    describe('array fields', () => {
+        it('should recursively filter array items', () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [
+                        { name: 'text', type: 'text', localized: true },
+                        { name: 'order', type: 'number' },
+                    ],
+                },
+            ];
+            const data = {
+                items: [
+                    { id: '1', text: 'First', order: 1 },
+                    { id: '2', text: 'Second', order: 2 },
+                ],
+            };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({
+                items: [
+                    { id: '1', text: 'First' },
+                    { id: '2', text: 'Second' },
+                ],
+            });
+        });
+        it('should exclude array if no localized fields inside items', () => {
+            const schema = [
+                {
+                    name: 'tags',
+                    type: 'array',
+                    fields: [{ name: 'name', type: 'text' }],
+                },
+            ];
+            const data = { tags: [{ id: '1', name: 'tag1' }] };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+    });
+    describe('blocks fields', () => {
+        it('should recursively filter blocks with blockType and id preserved', () => {
+            const schema = [
+                {
+                    name: 'content',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'text',
+                            fields: [
+                                { name: 'body', type: 'richText', localized: true },
+                                { name: 'alignment', type: 'select', options: ['left', 'center'] },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                content: [{ id: 'block1', blockType: 'text', body: { root: {} }, alignment: 'center' }],
+            };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({
+                content: [{ id: 'block1', blockType: 'text', body: { root: {} } }],
+            });
+        });
+        it('should handle multiple block types', () => {
+            const schema = [
+                {
+                    name: 'content',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'heading',
+                            fields: [{ name: 'title', type: 'text', localized: true }],
+                        },
+                        {
+                            slug: 'image',
+                            fields: [{ name: 'alt', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                content: [
+                    { id: '1', blockType: 'heading', title: 'Hello' },
+                    { id: '2', blockType: 'image', alt: 'Image alt' },
+                ],
+            };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({
+                content: [
+                    { id: '1', blockType: 'heading', title: 'Hello' },
+                    { id: '2', blockType: 'image', alt: 'Image alt' },
+                ],
+            });
+        });
+    });
+    describe('tabs fields', () => {
+        it('should process tabs as flat fields', () => {
+            const schema = [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            label: 'Content',
+                            fields: [{ name: 'title', type: 'text', localized: true }],
+                        },
+                        {
+                            label: 'Settings',
+                            fields: [{ name: 'slug', type: 'text' }],
+                        },
+                    ],
+                },
+            ];
+            const data = { title: 'Hello', slug: 'hello' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({ title: 'Hello' });
+        });
+    });
+    describe('row/collapsible fields', () => {
+        it('should process row fields as flat', () => {
+            const schema = [
+                {
+                    type: 'row',
+                    fields: [
+                        { name: 'firstName', type: 'text', localized: true },
+                        { name: 'lastName', type: 'text', localized: true },
+                    ],
+                },
+            ];
+            const data = { firstName: 'John', lastName: 'Doe' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({ firstName: 'John', lastName: 'Doe' });
+        });
+        it('should process collapsible fields', () => {
+            const schema = [
+                {
+                    type: 'collapsible',
+                    label: 'Advanced',
+                    fields: [{ name: 'meta', type: 'text', localized: true }],
+                },
+            ];
+            const data = { meta: 'Some meta' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({ meta: 'Some meta' });
+        });
+    });
+    describe('non-translatable fields', () => {
+        it('should filter out localized number field', () => {
+            const schema = [{ name: 'count', type: 'number', localized: true }];
+            const data = { count: 42 };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized checkbox field', () => {
+            const schema = [{ name: 'enabled', type: 'checkbox', localized: true }];
+            const data = { enabled: true };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized select field', () => {
+            const schema = [{ name: 'status', type: 'select', options: ['draft', 'published'], localized: true }];
+            const data = { status: 'draft' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized json field', () => {
+            const schema = [{ name: 'metadata', type: 'json', localized: true }];
+            const data = { metadata: { key: 'value' } };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized code field', () => {
+            const schema = [{ name: 'snippet', type: 'code', localized: true }];
+            const data = { snippet: 'const x = 1' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized point field', () => {
+            const schema = [{ name: 'location', type: 'point', localized: true }];
+            const data = { location: [0, 0] };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized relationship field', () => {
+            const schema = [{ name: 'author', type: 'relationship', relationTo: 'users', localized: true }];
+            const data = { author: '123' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized upload field', () => {
+            const schema = [{ name: 'image', type: 'upload', relationTo: 'media', localized: true }];
+            const data = { image: '456' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized date field', () => {
+            const schema = [{ name: 'publishedAt', type: 'date', localized: true }];
+            const data = { publishedAt: '2024-01-01' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should filter out localized email field', () => {
+            const schema = [{ name: 'contact', type: 'email', localized: true }];
+            const data = { contact: 'test@example.com' };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({});
+        });
+        it('should keep translatable fields while filtering non-translatable', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'count', type: 'number', localized: true },
+                { name: 'description', type: 'textarea', localized: true },
+                { name: 'status', type: 'select', options: ['a', 'b'], localized: true },
+                { name: 'body', type: 'richText', localized: true },
+            ];
+            const data = {
+                title: 'Hello',
+                count: 42,
+                description: 'World',
+                status: 'a',
+                body: { root: {} },
+            };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({
+                title: 'Hello',
+                description: 'World',
+                body: { root: {} },
+            });
+        });
+    });
+    describe('nested structures', () => {
+        it('should handle deeply nested localized fields', () => {
+            const schema = [
+                {
+                    name: 'sections',
+                    type: 'array',
+                    fields: [
+                        {
+                            name: 'content',
+                            type: 'blocks',
+                            blocks: [
+                                {
+                                    slug: 'text',
+                                    fields: [
+                                        {
+                                            name: 'wrapper',
+                                            type: 'group',
+                                            fields: [{ name: 'body', type: 'richText', localized: true }],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                sections: [
+                    {
+                        id: 's1',
+                        content: [{ id: 'b1', blockType: 'text', wrapper: { body: { root: {} } } }],
+                    },
+                ],
+            };
+            const result = filterLocalizedFields(schema, data);
+            expect(result).toEqual({
+                sections: [
+                    {
+                        id: 's1',
+                        content: [{ id: 'b1', blockType: 'text', wrapper: { body: { root: {} } } }],
+                    },
+                ],
+            });
+        });
+    });
+});

package/dist/server/shared/utils/getByPath.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gets a value from an object by dot-notation path.
+ *
+ * @example
+ * getByPath({ a: { b: 1 } }, 'a.b') // 1
+ * getByPath({ arr: [{ x: 1 }] }, 'arr.0.x') // 1
+ */
+export declare function getByPath(obj: Record<string, unknown>, path: string): unknown;
+//# sourceMappingURL=getByPath.d.ts.map

package/dist/server/shared/utils/getByPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getByPath.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/getByPath.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAU7E"}

package/dist/server/shared/utils/getByPath.js

@@ -0,0 +1,18 @@
+import { isObject } from './isObject';
+/**
+ * Gets a value from an object by dot-notation path.
+ *
+ * @example
+ * getByPath({ a: { b: 1 } }, 'a.b') // 1
+ * getByPath({ arr: [{ x: 1 }] }, 'arr.0.x') // 1
+ */ export function getByPath(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys){
+        if (!isObject(current)) return undefined;
+        current = current[key];
+    }
+    return current;
+}
+
+//# sourceMappingURL=getByPath.js.map

package/dist/server/shared/utils/getByPath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/shared/utils/getByPath.ts"],"sourcesContent":["import { isObject } from './isObject'\n\n/**\n * Gets a value from an object by dot-notation path.\n *\n * @example\n * getByPath({ a: { b: 1 } }, 'a.b') // 1\n * getByPath({ arr: [{ x: 1 }] }, 'arr.0.x') // 1\n */\nexport function getByPath(obj: Record<string, unknown>, path: string): unknown {\n  const keys = path.split('.')\n  let current: unknown = obj\n\n  for (const key of keys) {\n    if (!isObject(current)) return undefined\n    current = current[key]\n  }\n\n  return current\n}\n"],"names":["isObject","getByPath","obj","path","keys","split","current","key","undefined"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,aAAY;AAErC;;;;;;CAMC,GACD,OAAO,SAASC,UAAUC,GAA4B,EAAEC,IAAY;IAClE,MAAMC,OAAOD,KAAKE,KAAK,CAAC;IACxB,IAAIC,UAAmBJ;IAEvB,KAAK,MAAMK,OAAOH,KAAM;QACtB,IAAI,CAACJ,SAASM,UAAU,OAAOE;QAC/BF,UAAUA,OAAO,CAACC,IAAI;IACxB;IAEA,OAAOD;AACT"}

package/dist/server/shared/utils/getByPath.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getByPath.test.d.ts.map

package/dist/server/shared/utils/getByPath.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getByPath.test.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/getByPath.test.ts"],"names":[],"mappings":""}

package/dist/server/shared/utils/getByPath.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { getByPath } from './getByPath';
+describe('getByPath', () => {
+    it('gets top-level property', () => {
+        expect(getByPath({ title: 'Hello' }, 'title')).toBe('Hello');
+    });
+    it('gets nested property', () => {
+        expect(getByPath({ a: { b: { c: 1 } } }, 'a.b.c')).toBe(1);
+    });
+    it('gets array element', () => {
+        expect(getByPath({ arr: ['a', 'b', 'c'] }, 'arr.1')).toBe('b');
+    });
+    it('gets nested property in array', () => {
+        expect(getByPath({ items: [{ name: 'first' }, { name: 'second' }] }, 'items.1.name')).toBe('second');
+    });
+    it('returns undefined for missing path', () => {
+        expect(getByPath({ a: 1 }, 'b')).toBeUndefined();
+        expect(getByPath({ a: 1 }, 'a.b')).toBeUndefined();
+    });
+    it('returns undefined for null in path', () => {
+        expect(getByPath({ a: null }, 'a.b')).toBeUndefined();
+    });
+    it('handles complex nested structure', () => {
+        const obj = {
+            body: [
+                { blockType: 'text', content: { root: { children: [] } } },
+                { blockType: 'image', url: 'test.jpg' },
+            ],
+        };
+        expect(getByPath(obj, 'body.0.content.root.children')).toEqual([]);
+        expect(getByPath(obj, 'body.1.url')).toBe('test.jpg');
+    });
+});

package/dist/server/shared/utils/index.d.ts

@@ -0,0 +1,10 @@
+export { isEmpty } from './isEmpty';
+export { isObject } from './isObject';
+export { normalizePath } from './normalizePath';
+export { getByPath } from './getByPath';
+export { setByPath } from './setByPath';
+export { pipe } from './pipe';
+export { filterLocalizedFields } from './filterLocalizedFields';
+export { LazyMap } from './LazyMap';
+export type { LazyMapOptions } from './LazyMap';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/shared/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA"}

package/dist/server/shared/utils/index.js

@@ -0,0 +1,10 @@
+export { isEmpty } from './isEmpty';
+export { isObject } from './isObject';
+export { normalizePath } from './normalizePath';
+export { getByPath } from './getByPath';
+export { setByPath } from './setByPath';
+export { pipe } from './pipe';
+export { filterLocalizedFields } from './filterLocalizedFields';
+export { LazyMap } from './LazyMap';
+
+//# sourceMappingURL=index.js.map

package/dist/server/shared/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/shared/utils/index.ts"],"sourcesContent":["export { isEmpty } from './isEmpty'\nexport { isObject } from './isObject'\nexport { normalizePath } from './normalizePath'\nexport { getByPath } from './getByPath'\nexport { setByPath } from './setByPath'\nexport { pipe } from './pipe'\nexport { filterLocalizedFields } from './filterLocalizedFields'\nexport { LazyMap } from './LazyMap'\nexport type { LazyMapOptions } from './LazyMap'\n"],"names":["isEmpty","isObject","normalizePath","getByPath","setByPath","pipe","filterLocalizedFields","LazyMap"],"mappings":"AAAA,SAASA,OAAO,QAAQ,YAAW;AACnC,SAASC,QAAQ,QAAQ,aAAY;AACrC,SAASC,aAAa,QAAQ,kBAAiB;AAC/C,SAASC,SAAS,QAAQ,cAAa;AACvC,SAASC,SAAS,QAAQ,cAAa;AACvC,SAASC,IAAI,QAAQ,SAAQ;AAC7B,SAASC,qBAAqB,QAAQ,0BAAyB;AAC/D,SAASC,OAAO,QAAQ,YAAW"}

package/dist/server/shared/utils/isEmpty.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if a value is empty.
+ * Empty means: undefined, null, empty string (after trim), empty array, or empty object.
+ *
+ * Note: Does not handle complex types like richText.
+ * Use composition with type-specific checks (e.g., isEmptyRichText) for those.
+ */
+export declare function isEmpty(value: unknown): boolean;
+//# sourceMappingURL=isEmpty.d.ts.map

package/dist/server/shared/utils/isEmpty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEmpty.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/isEmpty.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM/C"}

package/dist/server/shared/utils/isEmpty.js

@@ -0,0 +1,15 @@
+/**
+ * Checks if a value is empty.
+ * Empty means: undefined, null, empty string (after trim), empty array, or empty object.
+ *
+ * Note: Does not handle complex types like richText.
+ * Use composition with type-specific checks (e.g., isEmptyRichText) for those.
+ */ export function isEmpty(value) {
+    if (value === undefined || value === null) return true;
+    if (typeof value === 'string' && value.trim() === '') return true;
+    if (Array.isArray(value) && value.length === 0) return true;
+    if (typeof value === 'object' && Object.keys(value).length === 0) return true;
+    return false;
+}
+
+//# sourceMappingURL=isEmpty.js.map

package/dist/server/shared/utils/isEmpty.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/shared/utils/isEmpty.ts"],"sourcesContent":["/**\n * Checks if a value is empty.\n * Empty means: undefined, null, empty string (after trim), empty array, or empty object.\n *\n * Note: Does not handle complex types like richText.\n * Use composition with type-specific checks (e.g., isEmptyRichText) for those.\n */\nexport function isEmpty(value: unknown): boolean {\n  if (value === undefined || value === null) return true\n  if (typeof value === 'string' && value.trim() === '') return true\n  if (Array.isArray(value) && value.length === 0) return true\n  if (typeof value === 'object' && Object.keys(value).length === 0) return true\n  return false\n}\n"],"names":["isEmpty","value","undefined","trim","Array","isArray","length","Object","keys"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,QAAQC,KAAc;IACpC,IAAIA,UAAUC,aAAaD,UAAU,MAAM,OAAO;IAClD,IAAI,OAAOA,UAAU,YAAYA,MAAME,IAAI,OAAO,IAAI,OAAO;IAC7D,IAAIC,MAAMC,OAAO,CAACJ,UAAUA,MAAMK,MAAM,KAAK,GAAG,OAAO;IACvD,IAAI,OAAOL,UAAU,YAAYM,OAAOC,IAAI,CAACP,OAAOK,MAAM,KAAK,GAAG,OAAO;IACzE,OAAO;AACT"}

package/dist/server/shared/utils/isEmpty.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isEmpty.test.d.ts.map

package/dist/server/shared/utils/isEmpty.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEmpty.test.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/isEmpty.test.ts"],"names":[],"mappings":""}

package/dist/server/shared/utils/isEmpty.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { isEmpty } from './isEmpty';
+describe('isEmpty', () => {
+    describe('null and undefined', () => {
+        it('returns true for undefined', () => {
+            expect(isEmpty(undefined)).toBe(true);
+        });
+        it('returns true for null', () => {
+            expect(isEmpty(null)).toBe(true);
+        });
+    });
+    describe('strings', () => {
+        it('returns true for empty string', () => {
+            expect(isEmpty('')).toBe(true);
+        });
+        it('returns true for whitespace-only string', () => {
+            expect(isEmpty('   ')).toBe(true);
+            expect(isEmpty('\t\n')).toBe(true);
+        });
+        it('returns false for non-empty string', () => {
+            expect(isEmpty('hello')).toBe(false);
+            expect(isEmpty('  hello  ')).toBe(false);
+        });
+    });
+    describe('arrays', () => {
+        it('returns true for empty array', () => {
+            expect(isEmpty([])).toBe(true);
+        });
+        it('returns false for non-empty array', () => {
+            expect(isEmpty([1])).toBe(false);
+            expect(isEmpty([null])).toBe(false);
+            expect(isEmpty([''])).toBe(false);
+        });
+    });
+    describe('objects', () => {
+        it('returns true for empty object', () => {
+            expect(isEmpty({})).toBe(true);
+        });
+        it('returns false for non-empty object', () => {
+            expect(isEmpty({ a: 1 })).toBe(false);
+            expect(isEmpty({ key: null })).toBe(false);
+            expect(isEmpty({ key: undefined })).toBe(false);
+        });
+    });
+    describe('other types', () => {
+        it('returns false for numbers', () => {
+            expect(isEmpty(0)).toBe(false);
+            expect(isEmpty(1)).toBe(false);
+            expect(isEmpty(-1)).toBe(false);
+            expect(isEmpty(NaN)).toBe(false);
+        });
+        it('returns false for booleans', () => {
+            expect(isEmpty(false)).toBe(false);
+            expect(isEmpty(true)).toBe(false);
+        });
+        it('returns false for functions', () => {
+            expect(isEmpty(() => { })).toBe(false);
+        });
+    });
+});

package/dist/server/shared/utils/isObject.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Type guard: Checks if value is a non-null object.
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=isObject.d.ts.map

package/dist/server/shared/utils/isObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObject.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/isObject.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}

package/dist/server/shared/utils/isObject.js

@@ -0,0 +1,7 @@
+/**
+ * Type guard: Checks if value is a non-null object.
+ */ export function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+
+//# sourceMappingURL=isObject.js.map

package/dist/server/shared/utils/isObject.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/shared/utils/isObject.ts"],"sourcesContent":["/**\n * Type guard: Checks if value is a non-null object.\n */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null\n}\n"],"names":["isObject","value"],"mappings":"AAAA;;CAEC,GACD,OAAO,SAASA,SAASC,KAAc;IACrC,OAAO,OAAOA,UAAU,YAAYA,UAAU;AAChD"}

package/dist/server/shared/utils/isObject.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isObject.test.d.ts.map

package/dist/server/shared/utils/isObject.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObject.test.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/isObject.test.ts"],"names":[],"mappings":""}

package/dist/server/shared/utils/isObject.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { isObject } from './isObject';
+describe('isObject', () => {
+    describe('returns true for objects', () => {
+        it('returns true for plain object', () => {
+            expect(isObject({})).toBe(true);
+            expect(isObject({ a: 1 })).toBe(true);
+        });
+        it('returns true for nested object', () => {
+            expect(isObject({ nested: { deep: true } })).toBe(true);
+        });
+        it('returns true for array (arrays are objects)', () => {
+            expect(isObject([])).toBe(true);
+            expect(isObject([1, 2, 3])).toBe(true);
+        });
+        it('returns true for Date', () => {
+            expect(isObject(new Date())).toBe(true);
+        });
+        it('returns true for RegExp', () => {
+            expect(isObject(/test/)).toBe(true);
+        });
+        it('returns true for object created with Object.create', () => {
+            expect(isObject(Object.create(null))).toBe(true);
+        });
+    });
+    describe('returns false for non-objects', () => {
+        it('returns false for null', () => {
+            expect(isObject(null)).toBe(false);
+        });
+        it('returns false for undefined', () => {
+            expect(isObject(undefined)).toBe(false);
+        });
+        it('returns false for string', () => {
+            expect(isObject('')).toBe(false);
+            expect(isObject('hello')).toBe(false);
+        });
+        it('returns false for number', () => {
+            expect(isObject(0)).toBe(false);
+            expect(isObject(42)).toBe(false);
+            expect(isObject(NaN)).toBe(false);
+        });
+        it('returns false for boolean', () => {
+            expect(isObject(true)).toBe(false);
+            expect(isObject(false)).toBe(false);
+        });
+        it('returns false for symbol', () => {
+            expect(isObject(Symbol('test'))).toBe(false);
+        });
+        it('returns false for bigint', () => {
+            expect(isObject(BigInt(123))).toBe(false);
+        });
+        it('returns false for function', () => {
+            expect(isObject(() => { })).toBe(false);
+            expect(isObject(function () { })).toBe(false);
+        });
+    });
+});