dirvi-lib 0.10.0 → 0.11.0-beta.12

package/dist/trees/tree-node/tree-node.arb.js

@@ -1,188 +0,0 @@
-import * as fc from 'fast-check';
-/**
- * Characters used for readable generated node IDs.
- */
-const smallLetterCharacters = Array.from('abcdefghijklmnopqrstuvwxyz');
-/**
- * Generates valid string IDs for test nodes. Note that the API just does
- * comparisons on the IDs so we can safely restrict to any subset.
- */
-export const testIdArb = fc.string({
-    unit: fc.constantFrom(...smallLetterCharacters),
-    minLength: 1,
-    maxLength: 8,
-});
-/**
- * Generates serializable application values for test nodes.
- */
-export const testValueArb = fc.integer({
-    min: -10_000,
-    max: 10_000,
-});
-const generatedLeafModel = (id, value) => {
-    const model = {
-        id,
-        value,
-    };
-    return {
-        model,
-        reachableModels: [{ path: [], model }],
-    };
-};
-function generatedUnloadedBranchModel(id, value) {
-    const model = {
-        id,
-        value,
-        children: null,
-    };
-    return {
-        model,
-        reachableModels: [{ path: [], model }],
-    };
-}
-/**
- * Creates the metadata for a loaded branch and all descendants reachable
- * through its loaded child collection.
- *
- * Child-array order is not semantically meaningful to the tree API. The
- * generator happens to use an array because `TreeNodeModel` is serializable.
- */
-function generatedLoadedBranchModel(id, value, children) {
-    const model = {
-        id,
-        value,
-        children: children.map(({ model: child }) => child),
-    };
-    const reachableDescendants = children.flatMap(({ model: childModel, reachableModels }) => reachableModels.map(({ path, model: reachableModel }) => ({
-        path: [childModel.id, ...path],
-        model: reachableModel,
-    })));
-    return {
-        model,
-        reachableModels: [{ path: [], model }, ...reachableDescendants],
-    };
-}
-/**
- * Generates a leaf model.
- */
-export const generatedLeafModelArb = fc
-    .tuple(testIdArb, testValueArb)
-    .map(([id, value]) => generatedLeafModel(id, value));
-/**
- * Generates an unloaded-branch model.
- */
-export const generatedUnloadedBranchModelArb = fc
-    .tuple(testIdArb, testValueArb)
-    .map(([id, value]) => generatedUnloadedBranchModel(id, value));
-/**
- * Generates either kind of terminal model.
- *
- * Both leaves and unloaded branches terminate path traversal.
- */
-const generatedTerminalModelArb = fc.oneof(generatedLeafModelArb, generatedUnloadedBranchModelArb);
-/**
- * Generates a leaf, an unloaded branch, or a loaded branch.
- *
- * Loaded branches have unique child IDs. Root IDs are made unique separately
- * when generating a forest.
- *
- * The weighted choice gives recursive open branches a geometric dropoff.
- */
-export const generatedNodeArb = fc.letrec((tie) => {
-    const generatedChildModelArb = tie('node');
-    /**
-     * Generates the loaded children of an open branch.
-     *
-     * Sibling IDs must be unique so that child lookup is unambiguous. The
-     * maximum length also limits the branching factor of recursive examples.
-     */
-    const generatedOpenChildrenArb = fc.uniqueArray(generatedChildModelArb, {
-        minLength: 0,
-        maxLength: 4,
-        size: 'medium',
-        selector: ({ model }) => model.id,
-    });
-    /**
-     * Generates an open branch and its reachable descendants.
-     */
-    const generatedLoadedBranchModelArb = fc
-        .tuple(testIdArb, testValueArb, generatedOpenChildrenArb)
-        .map(([id, value, children]) => generatedLoadedBranchModel(id, value, children));
-    return {
-        node: fc
-            .integer({
-            min: 0,
-            max: 9999,
-        })
-            .chain((choice) => 
-        // 5046 works for getAtPath tests, but too heavy for modifyAtPath tests
-        choice >= 5050
-            ? generatedLoadedBranchModelArb
-            : generatedTerminalModelArb),
-    };
-}).node;
-/**
- * Generates an array of generated nodes with unique sibling IDs.
- *
- * The result is suitable for use as the loaded children of an open branch.
- */
-export const generatedNodesArrayArb = fc.uniqueArray(generatedNodeArb, {
-    minLength: 0,
-    size: 'small',
-    selector: (generated) => generated.model.id,
-});
-/**
- * An array of root-level nodes and all paths that can be resolved through
- * those nodes.
- *
- * Paths through closed branches stop at the closed branch because its
- * descendants are not loaded.
- */
-export const nodeAndPathsArb = generatedNodeArb.map(({ model: root, reachableModels }) => ({
-    root,
-    pathEntries: reachableModels,
-}));
-/**
- * Generates root-level nodes and a path to one of their reachable nodes.
- *
- * Every generated path is valid for `getAtPath`; unreachable paths are not
- * included.
- */
-export const nodeAndPathAndExpectedArb = nodeAndPathsArb
-    .filter(({ pathEntries }) => pathEntries.length > 0)
-    .chain(({ root, pathEntries }) => fc.constantFrom(...pathEntries).map(({ path, model }) => ({
-    root,
-    path,
-    expected: model,
-})));
-/**
- * Generates root-level nodes and a path to one of their branch nodes.
- *
- * Both open and closed branches are included. A path to a closed branch is
- * valid, but a path through a closed branch cannot reach any descendants.
- */
-export const nodesArrayAndBranchPathArb = nodeAndPathsArb
-    .map(({ root, pathEntries }) => ({
-    root,
-    branchPathEntries: pathEntries.filter(({ model }) => 'children' in model),
-}))
-    .filter(({ branchPathEntries }) => branchPathEntries.length > 0)
-    .chain(({ root, branchPathEntries }) => fc.constantFrom(...branchPathEntries).map(({ path, model }) => ({
-    root,
-    path,
-    expected: model,
-})));
-/**
- * Generates a new array of loaded child nodes.
- *
- * The generated nodes have unique IDs, making the result suitable for use as
- * the children of an open branch.
- */
-export const newBranchesArb = generatedNodesArrayArb.map((generatedNodes) => generatedNodes.map(({ model }) => model));
-/**
- * Generates either a new array of loaded child nodes or `null`.
- *
- * An array represents an open branch, including an open branch with no
- * children. `null` represents a closed branch.
- */
-export const newBranchesOrNullArb = fc.oneof(newBranchesArb, fc.constant(null));

package/dist/trees/tree-node/tree-node.impl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-node.impl.d.ts","sourceRoot":"","sources":["../../../src/trees/tree-node/tree-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,WAAW,EAGZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,sBAAsB,CAAC;AAqJ3E;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,KAAK,KACF,WAAW,CAAC,EAAE,EAAE,KAAK,CAAC,CAiR1B"}

package/dist/trees/tree-node/tree-node.model.d.ts

@@ -1,78 +0,0 @@
-import { z } from 'zod';
-/**
- * A serializable primitive suitable for use as a stable tree-node ID.
- *
- * @remarks
- *
- * A node ID identifies a node among its direct siblings. It is not required
- * to be globally unique across the whole tree: two nodes in different
- * branches may have the same ID.
- *
- * Numeric IDs must be finite. TypeScript cannot represent the exclusion of
- * `NaN`, `Infinity`, and `-Infinity` from `number`, so values received from
- * an untrusted source should be validated at an application boundary, for
- * example with `serializableKeySchema`.
- *
- * Applications should normally define a narrower domain-specific ID type.
- * Branded ID types prevent IDs from unrelated domains from being mixed
- * accidentally, even when both use strings at runtime.
- *
- * @example
- *
- * ```ts
- * const menuIdSchema = z
- *   .string()
- *   .min(1)
- *   .brand<'MenuId'>();
- *
- * type MenuId = z.output<typeof menuIdSchema>;
- *
- * type MenuItem = Readonly<{
- *   label: string;
- *   href?: string;
- * }>;
- *
- * type MenuTree = TreeNode<MenuId, MenuItem>;
- * ```
- */
-export type SerializableKey = string | number;
-/**
- * Validates a serializable primitive suitable for use as a stable tree-node ID.
- *
- * Strings are always accepted. Numbers must be finite: `NaN`, `Infinity`, and
- * `-Infinity` are rejected.
- */
-export declare const serializableKeySchema: z.ZodType<SerializableKey>;
-/**
- * A structural, serializable snapshot of a tree node.
- *
- * This is a public persistence and interchange model for `TreeNode`; it is
- * not the runtime representation of an opaque `TreeNode` value.
- *
- * Loaded children are represented by an array because JSON has no native
- * unordered collection type. The array encodes an unordered collection of
- * sibling-unique nodes: its iteration order has no semantic meaning and is
- * not guaranteed to be preserved by `TreeNodeApi.fromModel`,
- * `TreeNodeApi.toModel`, or other tree operations.
- *
- * Applications that need visual or navigation order should derive ordered UI
- * rows from the tree using an explicit ordering policy.
- */
-export type TreeNodeModel<Id extends SerializableKey, Value> = LeafTreeNodeModel<Id, Value> | UnloadedBranchTreeNodeModel<Id, Value> | LoadedBranchTreeNodeModel<Id, Value>;
-export type LeafTreeNodeModel<Id extends SerializableKey, Value> = Readonly<{
-    id: Id;
-    value: Value;
-    children?: never;
-}>;
-export type UnloadedBranchTreeNodeModel<Id extends SerializableKey, Value> = Readonly<{
-    id: Id;
-    value: Value;
-    children: null;
-}>;
-export type LoadedBranchTreeNodeModel<Id extends SerializableKey, Value> = Readonly<{
-    id: Id;
-    value: Value;
-    children: readonly TreeNodeModel<Id, Value>[];
-}>;
-export declare function createTreeNodeModelSchema<Id extends SerializableKey, Value>(idSchema: z.ZodType<Id>, valueSchema: z.ZodType<Value>): z.ZodType<TreeNodeModel<Id, Value>>;
-//# sourceMappingURL=tree-node.model.d.ts.map

package/dist/trees/tree-node/tree-node.model.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-node.model.d.ts","sourceRoot":"","sources":["../../../src/trees/tree-node/tree-node.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAG3D,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IACvD,iBAAiB,CAAC,EAAE,EAAE,KAAK,CAAC,GAC5B,2BAA2B,CAAC,EAAE,EAAE,KAAK,CAAC,GACtC,yBAAyB,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;AAEzC,MAAM,MAAM,iBAAiB,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,QAAQ,CAAC;IAC1E,EAAE,EAAE,EAAE,CAAC;IACP,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,CAAC,EAAE,KAAK,CAAC;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,2BAA2B,CACrC,EAAE,SAAS,eAAe,EAC1B,KAAK,IACH,QAAQ,CAAC;IACX,EAAE,EAAE,EAAE,CAAC;IACP,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,IAAI,CAAC;CAChB,CAAC,CAAC;AAEH,MAAM,MAAM,yBAAyB,CACnC,EAAE,SAAS,eAAe,EAC1B,KAAK,IACH,QAAQ,CAAC;IACX,EAAE,EAAE,EAAE,CAAC;IACP,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,SAAS,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,CAAC;CAC/C,CAAC,CAAC;AAEH,wBAAgB,yBAAyB,CAAC,EAAE,SAAS,eAAe,EAAE,KAAK,EACzE,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,EACvB,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAC5B,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CA+BrC"}

package/dist/trees/tree-node/tree-node.model.js

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-/**
- * Validates a serializable primitive suitable for use as a stable tree-node ID.
- *
- * Strings are always accepted. Numbers must be finite: `NaN`, `Infinity`, and
- * `-Infinity` are rejected.
- */
-export const serializableKeySchema = z.union([
-    z.string(),
-    z.number(),
-]);
-export function createTreeNodeModelSchema(idSchema, valueSchema) {
-    let nodeSchema;
-    nodeSchema = z.lazy(() => z.union([
-        z
-            .object({
-            id: idSchema,
-            value: valueSchema,
-        })
-            .strict(),
-        z
-            .object({
-            id: idSchema,
-            value: valueSchema,
-            children: z.null(),
-        })
-            .strict(),
-        z
-            .object({
-            id: idSchema,
-            value: valueSchema,
-            children: z.array(nodeSchema),
-        })
-            .strict(),
-    ]));
-    return nodeSchema;
-}

package/dist/trees/tree-node/tree-node.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-node.types.d.ts","sourceRoot":"","sources":["../../../src/trees/tree-node/tree-node.types.ts"],"names":[],"mappings":"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"}