@adecore/plan 0.21.1 → 0.21.2

package/dist/apply.js

@@ -1,7 +1,7 @@
 import { PlanChecksSchema, PlanItemIdSchema, PlanKindSchema, PlanMetaSchema, PlanOpSchema, PlanSchema, PlanSectionSchema, PlanStepSchema, PlanStepStateSchema, PlanTextSchema } from './protocol.js';
 import { z } from 'zod';
 import { canApply } from './permissions.js';
-import { allItems, allSteps, effectiveChecks, locateItem, refuse, structureProblem } from './tree.js';
+import { allItems, allSteps, effectiveChecks, locateItem, missingItem, refuse, structureProblem } from './tree.js';
 const ID_ALPHABET = 'abcdefghijklmnopqrstuvwxyz0123456789';
 export function randomItemId() {
     const bytes = crypto.getRandomValues(new Uint8Array(6));
@@ -59,7 +59,7 @@ function placeFor(plan, type, under, after) {
     if (under !== undefined) {
         const location = locateItem(plan, under);
         if (!location) {
-            return refuse('plan-missing-item', `The plan has no item "${under}"`);
+            return missingItem(under);
         }
         const target = location.item;
         if (target.type === 'text') {
@@ -77,7 +77,7 @@ function placeFor(plan, type, under, after) {
     else if (after !== undefined) {
         const location = locateItem(plan, after);
         if (!location) {
-            return refuse('plan-missing-item', `The plan has no item "${after}"`);
+            return missingItem(after);
         }
         parent = location.parent;
         siblings = location.siblings;
@@ -116,6 +116,16 @@ function pruneEmptySteps(items) {
         }
     }
 }
+function newItem(op, id) {
+    const base = { id, title: op.title, ...(op.description ? { description: op.description } : {}) };
+    if (op.type === 'section') {
+        return { type: 'section', ...base, items: [] };
+    }
+    if (op.type === 'text') {
+        return { type: 'text', ...base };
+    }
+    return { type: 'step', ...base, ...(op.checks ? { checks: op.checks } : {}) };
+}
 function applyOne(plan, op, options, mint, dropped) {
     const verdict = canApply(op, options.actor, plan);
     if (!verdict.ok) {
@@ -160,13 +170,7 @@ function applyOne(plan, op, options, mint, dropped) {
             if ('ok' in place) {
                 return place;
             }
-            const base = { id, title: op.title, ...(op.description ? { description: op.description } : {}) };
-            const item = op.type === 'section'
-                ? { type: 'section', ...base, items: [] }
-                : op.type === 'text'
-                    ? { type: 'text', ...base }
-                    : { type: 'step', ...base, ...(op.checks ? { checks: op.checks } : {}) };
-            place.siblings.splice(place.index, 0, item);
+            place.siblings.splice(place.index, 0, newItem(op, id));
             becomeParent(place.parent, dropped);
             return null;
         }

package/dist/permissions.js

@@ -1,11 +1,11 @@
-import { allSteps, effectiveChecks, holdsPersonState, isParentStep, locateItem, refuse } from './tree.js';
+import { allSteps, effectiveChecks, holdsPersonState, isParentStep, locateItem, missingItem, refuse } from './tree.js';
 const ALLOWED = { ok: true };
 const PERSON_OPS = new Set(['set', 'note', 'unlock']);
 const AGENT_OPS = new Set(['set', 'note', 'add', 'edit', 'move', 'remove', 'meta']);
 function stepFor(plan, id, leaf) {
     const location = locateItem(plan, id);
     if (!location) {
-        return refuse('plan-missing-item', `The plan has no item "${id}"`);
+        return missingItem(id);
     }
     if (location.item.type !== 'step') {
         return refuse('plan-not-a-step', `"${id}" is a ${location.item.type}, not a step`);
@@ -90,7 +90,7 @@ export function canApply(op, actor, plan) {
         case 'edit': {
             const location = locateItem(plan, op.id);
             if (!location) {
-                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+                return missingItem(op.id);
             }
             const item = location.item;
             if (item.type !== 'step') {
@@ -118,14 +118,14 @@ export function canApply(op, actor, plan) {
         }
         case 'move': {
             if (!locateItem(plan, op.id)) {
-                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+                return missingItem(op.id);
             }
             return mayHoldChildren(plan, op.under);
         }
         case 'remove': {
             const location = locateItem(plan, op.id);
             if (!location) {
-                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+                return missingItem(op.id);
             }
             if (holdsPersonState(location.item)) {
                 return refuse('set-by-person', `A person checked "${op.id}" or a step under it, so it stays`);

package/dist/tree.d.ts

@@ -6,6 +6,7 @@ export interface PlanRefusal {
     message: string;
 }
 export declare function refuse(code: PlanRefusalCode, message: string): PlanRefusal;
+export declare function missingItem(id: string): PlanRefusal;
 export interface PlanLocation {
     item: PlanItem;
     siblings: PlanItem[];

package/dist/tree.js

@@ -2,6 +2,9 @@ import { PLAN_LIMITS } from './protocol.js';
 export function refuse(code, message) {
     return { ok: false, code, message };
 }
+export function missingItem(id) {
+    return refuse('plan-missing-item', `The plan has no item "${id}"`);
+}
 function childrenOf(item) {
     if (item.type === 'section') {
         return item.items;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/plan",
-  "version": "0.21.1",
+  "version": "0.21.2",
   "description": "Plan schemas, atomic tree operations, actor permissions and Markdown.",
   "license": "FSL-1.1-MIT",
   "author": "Bas Milius",

package/src/apply.ts

@@ -21,7 +21,7 @@ import {
 } from './protocol.ts';
 import { z } from 'zod';
 import { canApply } from './permissions.ts';
-import { allItems, allSteps, effectiveChecks, locateItem, refuse, structureProblem, type PlanRefusal } from './tree.ts';
+import { allItems, allSteps, effectiveChecks, locateItem, missingItem, refuse, structureProblem, type PlanRefusal } from './tree.ts';
 
 export interface PlanApplyOptions {
     actor: PlanActor;
@@ -107,7 +107,7 @@ function placeFor(
     if (under !== undefined) {
         const location = locateItem(plan, under);
         if (!location) {
-            return refuse('plan-missing-item', `The plan has no item "${under}"`);
+            return missingItem(under);
         }
         const target = location.item;
         if (target.type === 'text') {
@@ -123,7 +123,7 @@ function placeFor(
     } else if (after !== undefined) {
         const location = locateItem(plan, after);
         if (!location) {
-            return refuse('plan-missing-item', `The plan has no item "${after}"`);
+            return missingItem(after);
         }
         parent = location.parent;
         siblings = location.siblings;
@@ -165,6 +165,17 @@ function pruneEmptySteps(items: readonly PlanItem[]): void {
     }
 }
 
+function newItem(op: Extract<PlanOp, { op: 'add' }>, id: string): PlanItem {
+    const base = { id, title: op.title, ...(op.description ? { description: op.description } : {}) };
+    if (op.type === 'section') {
+        return { type: 'section', ...base, items: [] };
+    }
+    if (op.type === 'text') {
+        return { type: 'text', ...base };
+    }
+    return { type: 'step', ...base, ...(op.checks ? { checks: op.checks } : {}) };
+}
+
 function applyOne(plan: Plan, op: PlanOp, options: PlanApplyOptions, mint: () => string, dropped: string[]): PlanRefusal | null {
     const verdict = canApply(op, options.actor, plan);
     if (!verdict.ok) {
@@ -209,14 +220,7 @@ function applyOne(plan: Plan, op: PlanOp, options: PlanApplyOptions, mint: () =>
             if ('ok' in place) {
                 return place;
             }
-            const base = { id, title: op.title, ...(op.description ? { description: op.description } : {}) };
-            const item: PlanItem =
-                op.type === 'section'
-                    ? { type: 'section', ...base, items: [] }
-                    : op.type === 'text'
-                      ? { type: 'text', ...base }
-                      : { type: 'step', ...base, ...(op.checks ? { checks: op.checks } : {}) };
-            place.siblings.splice(place.index, 0, item);
+            place.siblings.splice(place.index, 0, newItem(op, id));
             becomeParent(place.parent, dropped);
             return null;
         }

package/src/permissions.ts

@@ -1,5 +1,5 @@
 import type { Plan, PlanActor, PlanOp, PlanStep, PlanStepState } from './protocol.ts';
-import { allSteps, effectiveChecks, holdsPersonState, isParentStep, locateItem, refuse, type PlanRefusal } from './tree.ts';
+import { allSteps, effectiveChecks, holdsPersonState, isParentStep, locateItem, missingItem, refuse, type PlanRefusal } from './tree.ts';
 
 export type PlanVerdict = { ok: true } | PlanRefusal;
 
@@ -11,7 +11,7 @@ const AGENT_OPS: ReadonlySet<PlanOp['op']> = new Set(['set', 'note', 'add', 'edi
 function stepFor(plan: Plan, id: string, leaf: boolean): PlanStep | PlanRefusal {
     const location = locateItem(plan, id);
     if (!location) {
-        return refuse('plan-missing-item', `The plan has no item "${id}"`);
+        return missingItem(id);
     }
     if (location.item.type !== 'step') {
         return refuse('plan-not-a-step', `"${id}" is a ${location.item.type}, not a step`);
@@ -99,7 +99,7 @@ export function canApply(op: PlanOp, actor: PlanActor, plan: Plan): PlanVerdict
         case 'edit': {
             const location = locateItem(plan, op.id);
             if (!location) {
-                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+                return missingItem(op.id);
             }
             const item = location.item;
             if (item.type !== 'step') {
@@ -127,14 +127,14 @@ export function canApply(op: PlanOp, actor: PlanActor, plan: Plan): PlanVerdict
         }
         case 'move': {
             if (!locateItem(plan, op.id)) {
-                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+                return missingItem(op.id);
             }
             return mayHoldChildren(plan, op.under);
         }
         case 'remove': {
             const location = locateItem(plan, op.id);
             if (!location) {
-                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+                return missingItem(op.id);
             }
             if (holdsPersonState(location.item)) {
                 return refuse('set-by-person', `A person checked "${op.id}" or a step under it, so it stays`);

package/src/tree.ts

@@ -27,6 +27,10 @@ export function refuse(code: PlanRefusalCode, message: string): PlanRefusal {
     return { ok: false, code, message };
 }
 
+export function missingItem(id: string): PlanRefusal {
+    return refuse('plan-missing-item', `The plan has no item "${id}"`);
+}
+
 /* Where an item stands: the array that holds it, so an operation can splice it, and the step or section around it. */
 export interface PlanLocation {
     item: PlanItem;