polen 0.11.0-next.17 → 0.11.0-next.19

package/build/template/routes/changelog.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"changelog.d.ts","sourceRoot":"","sources":["../../../src/template/routes/changelog.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AA+OtC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqBlB,CAAA"}

package/build/template/routes/changelog.js

@@ -1,168 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Catalog } from '#lib/catalog';
-import { Change } from '#lib/change';
-import { route } from '#lib/react-router-effect/route';
-import { useLoaderData } from '#lib/react-router-effect/use-loader-data';
-import { Revision } from '#lib/revision';
-import { Swiss } from '#lib/swiss';
-import { Version } from '#lib/version';
-import { Box, Flex, Text } from '@radix-ui/themes';
-import { Effect, HashMap, Option } from 'effect';
-import React, { useEffect, useMemo, useState } from 'react';
-import { useParams } from 'react-router';
-import { schemasCatalog } from 'virtual:polen/project/schemas';
-import { Changelog } from '../components/Changelog/Changelog.js';
-import { renderDate } from '../components/Changelog/Changelog.js';
-import { ChangelogVersionPicker } from '../components/Changelog/ChangelogVersionPicker.js';
-const calculateCounts = (revision) => {
-    return {
-        breaking: revision.changes.filter(Change.isBreaking).length,
-        dangerous: revision.changes.filter(Change.isDangerous).length,
-        safe: revision.changes.filter(Change.isSafe).length,
-    };
-};
-const SidebarEntry = ({ revision, counts, isActive }) => {
-    const dateId = revision.date;
-    return (_jsx(Box, { mb: '2', children: _jsxs("a", { href: `#${dateId}`, style: {
-                textDecoration: 'none',
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'space-between',
-                padding: '0.5rem 0.75rem',
-                borderRadius: '4px',
-                backgroundColor: isActive ? 'var(--gray-a3)' : 'transparent',
-                color: 'inherit',
-                transition: 'background-color 0.2s',
-            }, onClick: (e) => {
-                e.preventDefault();
-                // Update URL hash
-                window.history.pushState(null, '', `#${dateId}`);
-                // Dispatch custom event for pushState
-                window.dispatchEvent(new Event('pushstate'));
-                // Smooth scroll to element
-                document.getElementById(dateId)?.scrollIntoView({ behavior: 'smooth' });
-            }, children: [_jsx(Text, { size: '2', weight: isActive ? 'medium' : 'regular', children: renderDate(revision.date) }), _jsxs(Flex, { gap: '2', align: 'center', children: [counts.breaking > 0 && (_jsx(Text, { size: '1', weight: 'medium', style: { color: '#ef4444' }, children: counts.breaking })), counts.dangerous > 0 && (_jsx(Text, { size: '1', weight: 'medium', style: { color: '#f59e0b' }, children: counts.dangerous })), counts.safe > 0 && (_jsx(Text, { size: '1', weight: 'medium', style: { color: '#10b981' }, children: counts.safe }))] })] }) }));
-};
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • Schema
-//
-//
-const schema = Catalog.Catalog;
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • Loader
-//
-//
-const changelogLoader = () => {
-    // This should never be called when schemasCatalog is null
-    // because the route won't be added to the router
-    // But we return an Effect.fail for safety
-    if (!schemasCatalog) {
-        return Effect.fail(new Error('No schema catalog available. This page requires a GraphQL schema to be configured. '
-            + 'Please ensure your Polen configuration includes a valid schema source.'));
-    }
-    return Effect.succeed(schemasCatalog);
-};
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • Component
-//
-//
-const Component = () => {
-    const catalog = useLoaderData(schema);
-    const [activeRevision, setActiveRevision] = useState(null);
-    const params = useParams();
-    const urlVersion = params['version'];
-    // Get available versions if catalog is versioned
-    const availableVersions = useMemo(() => {
-        if (Catalog.Versioned.is(catalog)) {
-            return Catalog.Versioned.getVersions(catalog).map(Version.encodeSync);
-        }
-        return [];
-    }, [catalog]);
-    // Get revisions for the current version (for sidebar)
-    const revisions = useMemo(() => {
-        if (Catalog.Unversioned.is(catalog)) {
-            return catalog.schema.revisions;
-        }
-        else {
-            // For versioned catalogs, show only current version's revisions
-            if (urlVersion) {
-                const entryOption = Option.map(HashMap.findFirst(catalog.entries, (_, key) => Version.encodeSync(key) === urlVersion), ([, value]) => value);
-                return Option.match(entryOption, {
-                    onNone: () => [],
-                    onSome: (entry) => entry.revisions,
-                });
-            }
-            // No revisions if no version selected (will redirect)
-            return [];
-        }
-    }, [catalog, urlVersion]);
-    // Calculate counts for all revisions (SSR-safe)
-    const revisionsWithCounts = revisions.map(revision => ({
-        revision,
-        counts: calculateCounts(revision),
-    }));
-    // Track active revision based on URL hash
-    useEffect(() => {
-        const handleHashChange = () => {
-            const hash = window.location.hash.slice(1);
-            setActiveRevision(hash || null);
-        };
-        // Set initial active revision
-        handleHashChange();
-        // Listen for hash changes
-        window.addEventListener('hashchange', handleHashChange);
-        // Listen for pushState/replaceState (custom event we'll dispatch)
-        window.addEventListener('pushstate', handleHashChange);
-        return () => {
-            window.removeEventListener('hashchange', handleHashChange);
-            window.removeEventListener('pushstate', handleHashChange);
-        };
-    }, []);
-    return (_jsxs(Swiss.Body, { subgrid: true, children: [_jsxs(Swiss.Item, { cols: 4, style: {
-                    position: 'sticky',
-                    top: '2rem',
-                    height: 'fit-content',
-                    minWidth: '250px',
-                    maxHeight: 'calc(100vh - 4rem)',
-                    overflowY: 'auto',
-                }, children: [Catalog.Versioned.is(catalog) && availableVersions.length > 1 && urlVersion && (_jsx(Box, { mb: '3', children: _jsx(ChangelogVersionPicker, { versions: availableVersions, currentVersion: urlVersion }) })), _jsx(Text, { size: '2', weight: 'medium', mb: '3', style: { display: 'block' }, children: "Revisions" }), revisionsWithCounts.map(({ revision, counts }) => (_jsx(SidebarEntry, { revision: revision, counts: counts, isActive: activeRevision === revision.date }, revision.date)))] }), _jsx(Swiss.Item, { start: 6, cols: 7, children: _jsx(Changelog, { catalog: catalog }) })] }));
-};
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • Routes
-//
-//
-export const changelog = !schemasCatalog
-    ? null
-    : route({
-        schema,
-        path: `changelog`,
-        loader: changelogLoader,
-        Component,
-        children: [
-            // Support deep linking to specific version
-            route({
-                path: `version/:version`,
-                loader: changelogLoader,
-                Component,
-            }),
-            // Support deep linking to specific version/revision
-            route({
-                path: `version/:version/revision/:revision`,
-                loader: changelogLoader,
-                Component,
-            }),
-        ],
-    });
-//# sourceMappingURL=changelog.js.map

package/build/template/routes/changelog.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"changelog.js","sourceRoot":"","sources":["../../../src/template/routes/changelog.tsx"],"names":[],"mappings":"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"}

package/src/lib/graph/$$.ts

@@ -1 +0,0 @@
-export * from './graph.js'

package/src/lib/graph/$.ts

@@ -1 +0,0 @@
-export * as Graph from './$$.js'

package/src/lib/graph/graph.ts

@@ -1,197 +0,0 @@
-import { S } from '#lib/kit-temp/effect'
-
-// ─── Schema ──────────────────────────────────────────────────────────────────
-
-/**
- * Dependency graph for tracking relationships between nodes
- * Used to efficiently handle dependencies in various contexts
- */
-export const DependencyGraph = S.Struct({
-  /**
-   * Map from parent ID to array of child IDs (parent depends on children)
-   */
-  dependencies: S.Record({ key: S.String, value: S.Array(S.String) }),
-
-  /**
-   * Map from child ID to array of parent IDs (child is depended on by parents)
-   */
-  dependents: S.Record({ key: S.String, value: S.Array(S.String) }),
-}).annotations({
-  identifier: 'DependencyGraph',
-  description: 'A directed graph tracking dependencies between nodes',
-})
-
-export type DependencyGraph = typeof DependencyGraph.Type
-
-// ─── Constructors ────────────────────────────────────────────────────────────
-
-export const make = DependencyGraph.make
-
-/**
- * Create an empty dependency graph
- */
-export const create = (): DependencyGraph =>
-  make({
-    dependencies: {},
-    dependents: {},
-  })
-
-// ─── Domain Logic ────────────────────────────────────────────────────────────
-
-/**
- * Add a dependency relationship (immutable)
- * @param graph - The dependency graph
- * @param parent - The parent node ID
- * @param child - The child node ID that the parent depends on
- * @returns A new graph with the dependency added
- */
-export const addDependency = (
-  graph: DependencyGraph,
-  parent: string,
-  child: string,
-): DependencyGraph => {
-  // Get existing arrays or create empty ones
-  const children = graph.dependencies[parent] || []
-  const parents = graph.dependents[child] || []
-
-  // Add child if not already present
-  const newChildren = children.includes(child) ? children : [...children, child]
-
-  // Add parent if not already present
-  const newParents = parents.includes(parent) ? parents : [...parents, parent]
-
-  return make({
-    dependencies: {
-      ...graph.dependencies,
-      [parent]: newChildren,
-    },
-    dependents: {
-      ...graph.dependents,
-      [child]: newParents,
-    },
-  })
-}
-
-/**
- * Add a dependency relationship (mutable)
- * @param graph - The dependency graph to mutate
- * @param parent - The parent node ID
- * @param child - The child node ID that the parent depends on
- */
-export const addDependencyMutable = (
-  graph: DependencyGraph,
-  parent: string,
-  child: string,
-): void => {
-  // Cast to mutable for mutation
-  const mutableGraph = graph as {
-    dependencies: Record<string, string[]>
-    dependents: Record<string, string[]>
-  }
-
-  // Add to dependencies
-  if (!mutableGraph.dependencies[parent]) {
-    mutableGraph.dependencies[parent] = []
-  }
-  if (!mutableGraph.dependencies[parent].includes(child)) {
-    mutableGraph.dependencies[parent].push(child)
-  }
-
-  // Add to dependents
-  if (!mutableGraph.dependents[child]) {
-    mutableGraph.dependents[child] = []
-  }
-  if (!mutableGraph.dependents[child].includes(parent)) {
-    mutableGraph.dependents[child].push(parent)
-  }
-}
-
-/**
- * Find all nodes that have no dependencies (leaf nodes)
- */
-export const findLeafNodes = (graph: DependencyGraph): Set<string> => {
-  const leaves = new Set<string>()
-
-  // Check all nodes that appear as children
-  for (const child of Object.keys(graph.dependents)) {
-    const deps = graph.dependencies[child]
-    if (!deps || deps.length === 0) {
-      leaves.add(child)
-    }
-  }
-
-  return leaves
-}
-
-/**
- * Check if all dependencies of a node have been processed
- */
-export const areDependenciesReady = (
-  node: string,
-  graph: DependencyGraph,
-  processed: Set<string>,
-): boolean => {
-  const deps = graph.dependencies[node]
-  if (!deps) return true
-
-  return deps.every(dep => processed.has(dep))
-}
-
-/**
- * Get topological ordering of nodes (children before parents)
- * This ensures we process dependencies before the nodes that depend on them
- *
- * @param graph - The dependency graph
- * @returns Array of node IDs in topological order
- */
-export const topologicalSort = (graph: DependencyGraph): string[] => {
-  const result: string[] = []
-  const visited = new Set<string>()
-  const visiting = new Set<string>() // For cycle detection
-
-  // Get all nodes
-  const allNodes = new Set<string>()
-  for (const parent of Object.keys(graph.dependencies)) {
-    allNodes.add(parent)
-  }
-  for (const child of Object.keys(graph.dependents)) {
-    allNodes.add(child)
-  }
-
-  const visit = (node: string): void => {
-    if (visited.has(node)) return
-
-    if (visiting.has(node)) {
-      // Cycle detected - just skip this node
-      return
-    }
-
-    visiting.add(node)
-
-    // Visit all children first
-    const children = graph.dependencies[node]
-    if (children) {
-      for (const child of children) {
-        visit(child)
-      }
-    }
-
-    visiting.delete(node)
-    visited.add(node)
-    result.push(node)
-  }
-
-  // Visit all nodes
-  for (const node of allNodes) {
-    visit(node)
-  }
-
-  return result
-}
-
-// ─── Codec ───────────────────────────────────────────────────────────────────
-
-export const decode = S.decode(DependencyGraph)
-export const decodeSync = S.decodeSync(DependencyGraph)
-export const encode = S.encode(DependencyGraph)
-export const encodeSync = S.encodeSync(DependencyGraph)

package/src/lib/mask/$$.ts

@@ -1,2 +0,0 @@
-export * from './apply.js'
-export * from './mask.js'

package/src/lib/mask/$.test.ts

@@ -1,226 +0,0 @@
-import * as fc from 'fast-check'
-import { describe, expect, test } from 'vitest'
-import { Test } from '../../../tests/unit/helpers/test.js'
-import { Mask } from './$.js'
-
-// dprint-ignore
-Test.suite<{ options: any; expectedType: 'binary' | 'properties'; expectedMode?: 'allow' | 'deny'; expectedShow?: boolean; expectedProperties?: string[] }>('Mask.create', [
-  { name: 'boolean true creates binary show mask',       options: true,                                        expectedType: 'binary',     expectedShow: true },
-  { name: 'boolean false creates binary hide mask',      options: false,                                       expectedType: 'binary',     expectedShow: false },
-  { name: 'array creates allow mode properties mask',    options: ['name', 'age'],                             expectedType: 'properties', expectedMode: 'allow', expectedProperties: ['name', 'age'] },
-  { name: 'object with true values creates allow mode',  options: { name: true, age: true, password: false },  expectedType: 'properties', expectedMode: 'allow', expectedProperties: ['name', 'age'] },
-  { name: 'object with false values creates deny mode',  options: { password: false, secret: false },          expectedType: 'properties', expectedMode: 'deny',  expectedProperties: ['password', 'secret'] },
-], ({ options, expectedType, expectedMode, expectedShow, expectedProperties }) => {
-  const mask = Mask.create(options)
-  expect(mask.type).toBe(expectedType)
-  
-  if (expectedType === 'binary' && mask.type === 'binary') {
-    expect(mask.show).toBe(expectedShow)
-  }
-  
-  if (expectedType === 'properties' && mask.type === 'properties') {
-    expect(mask.mode).toBe(expectedMode)
-    expect(mask.properties).toEqual(expectedProperties)
-  }
-})
-
-// dprint-ignore
-Test.suite<{ data: any; maskOptions: any; shouldThrow?: boolean; expected?: any }>('Mask.apply', [
-  { name: 'binary show mask returns data',               data: { a: 1 },                                 maskOptions: true,              expected: { a: 1 } },
-  { name: 'binary hide mask returns undefined',          data: { a: 1 },                                 maskOptions: false,             expected: undefined },
-  { name: 'allow mode filters properties',               data: { name: 'John', age: 30, password: 'secret' }, maskOptions: ['name', 'age'],    expected: { name: 'John', age: 30 } },
-  { name: 'deny mode removes properties',                data: { name: 'John', age: 30, password: 'secret' }, maskOptions: { password: false }, expected: { name: 'John', age: 30 } },
-  { name: 'properties mask throws for string',           data: 'string',                                 maskOptions: ['name'],          shouldThrow: true },
-  { name: 'properties mask throws for number',           data: 123,                                      maskOptions: ['name'],          shouldThrow: true },
-  { name: 'properties mask throws for null',             data: null,                                     maskOptions: ['name'],          shouldThrow: true },
-], ({ data, maskOptions, shouldThrow, expected }) => {
-  const mask = Mask.create(maskOptions)
-  
-  if (shouldThrow) {
-    expect(() => Mask.apply(data as any, mask)).toThrow()
-  } else {
-    const result = Mask.apply(data, mask)
-    if (expected === undefined) {
-      expect(result).toBe(undefined)
-    } else {
-      expect(result).toEqual(expected)
-    }
-  }
-})
-
-// dprint-ignore
-Test.suite<{ method: 'applyPartial' | 'applyExact'; data: any; maskOptions: any; expected: any }>('apply variants', [
-  { name: 'applyPartial allows missing properties',      method: 'applyPartial', data: { name: 'John' },  maskOptions: ['name', 'age'], expected: { name: 'John' } },
-  { name: 'applyPartial with empty object',              method: 'applyPartial', data: {},                maskOptions: ['name', 'age'], expected: {} },
-  { name: 'applyExact with binary show mask',            method: 'applyExact',   data: 'hello',           maskOptions: true,             expected: 'hello' },
-  { name: 'applyExact with binary hide mask',            method: 'applyExact',   data: 'hello',           maskOptions: false,            expected: undefined },
-], ({ method, data, maskOptions, expected }) => {
-  const mask = Mask.create(maskOptions)
-  
-  const result = method === 'applyPartial' 
-    ? Mask.applyPartial(data, mask)
-    : Mask.applyExact(data as any, mask)
-    
-  if (expected === undefined) {
-    expect(result).toBe(undefined)
-  } else {
-    expect(result).toEqual(expected)
-  }
-})
-
-describe('property-based tests', () => {
-  test('binary masks - invariants', () => {
-    fc.assert(
-      fc.property(fc.anything(), (data) => {
-        expect(Mask.apply(data, Mask.create(true))).toBe(data)
-        expect(Mask.apply(data, Mask.create(false))).toBe(undefined)
-      }),
-    )
-  })
-
-  test('properties mask - allow mode filters correctly', () => {
-    fc.assert(
-      fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
-        fc.array(fc.string(), { minLength: 1 }),
-        (obj, keys) => {
-          const mask = Mask.create(keys)
-          const result = Mask.apply(obj as any, mask)
-          const resultKeys = Object.keys(result as any)
-
-          // Result contains only keys that were in both mask and object
-          expect(resultKeys.every(key => keys.includes(key))).toBe(true)
-
-          // All requested keys that are own properties of obj are in result
-          keys.forEach(key => {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-              expect(result).toHaveProperty(key, (obj as any)[key])
-            }
-          })
-        },
-      ),
-    )
-  })
-
-  test('properties mask - deny mode filters correctly', () => {
-    fc.assert(
-      fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
-        fc.uniqueArray(fc.string(), { minLength: 1 }),
-        (data, keysToRemove) => {
-          const maskSpec = Object.fromEntries(keysToRemove.map(k => [k, false]))
-          const mask = Mask.create(maskSpec)
-
-          expect(mask.type).toBe('properties')
-          if (mask.type !== 'properties') return
-          expect(mask.mode).toBe('deny')
-
-          const result = Mask.apply(data as any, mask)
-
-          // Result should not have any of the denied keys
-          keysToRemove.forEach(key => {
-            expect(Object.prototype.hasOwnProperty.call(result, key)).toBe(false)
-          })
-
-          // Result should have all other keys from data
-          Object.keys(data).forEach(key => {
-            if (!keysToRemove.includes(key)) {
-              expect(Object.prototype.hasOwnProperty.call(result, key)).toBe(true)
-              expect((result as any)[key]).toBe((data as any)[key])
-            }
-          })
-        },
-      ),
-    )
-  })
-
-  test('undefined values are preserved', () => {
-    fc.assert(
-      fc.property(
-        fc.record({
-          a: fc.oneof(fc.anything(), fc.constant(undefined)),
-          b: fc.oneof(fc.anything(), fc.constant(undefined)),
-          c: fc.oneof(fc.anything(), fc.constant(undefined)),
-        }),
-        fc.shuffledSubarray(['a', 'b', 'c'], { minLength: 1 }),
-        (obj, keys) => {
-          const result = Mask.apply(obj as any, Mask.create(keys))
-
-          keys.forEach(key => {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-              expect(result).toHaveProperty(key)
-              expect((result as any)[key]).toBe((obj as any)[key])
-            }
-          })
-        },
-      ),
-    )
-  })
-
-  test('apply and applyPartial are consistent for complete data', () => {
-    fc.assert(
-      fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
-        fc.array(fc.string(), { minLength: 1 }),
-        (data, keys) => {
-          const mask = Mask.create(keys)
-          expect(Mask.apply(data as any, mask)).toEqual(Mask.applyPartial(data as any, mask))
-        },
-      ),
-    )
-  })
-
-  test('non-objects throw with properties masks', () => {
-    fc.assert(
-      fc.property(
-        fc.oneof(
-          fc.string(),
-          fc.integer(),
-          fc.boolean(),
-          fc.constant(null),
-          fc.constant(undefined),
-        ),
-        fc.array(fc.string(), { minLength: 1 }),
-        (nonObject, keys) => {
-          const mask = Mask.create(keys)
-          expect(() => Mask.apply(nonObject as any, mask)).toThrow('Cannot apply properties mask to non-object data')
-        },
-      ),
-    )
-  })
-
-  test('immutability invariants', () => {
-    fc.assert(
-      fc.property(
-        fc.dictionary(
-          fc.string(),
-          fc.oneof(
-            fc.string(),
-            fc.integer(),
-            fc.boolean(),
-            fc.constant(null),
-          ),
-        ),
-        fc.oneof(
-          fc.boolean(),
-          fc.array(fc.string()),
-          fc.dictionary(fc.string(), fc.boolean()),
-        ),
-        (data, maskOptions) => {
-          const mask = Mask.create(maskOptions as any)
-          const originalData = { ...data }
-          const originalMask = JSON.parse(JSON.stringify(mask))
-
-          try {
-            Mask.apply(data as any, mask)
-          } catch {
-            // Ignore errors for invalid combinations
-          }
-
-          expect(data).toEqual(originalData)
-          expect(mask).toEqual(originalMask)
-        },
-      ),
-    )
-  })
-})

package/src/lib/mask/$.ts

@@ -1 +0,0 @@
-export * as Mask from './$$.js'