@26lights/orcha 0.42.186 → 0.42.188

package/dist/src/components/AoActivityDetails.vue.d.ts

@@ -6,6 +6,10 @@ interface CreateSprintPayload {
     endDate: string;
 }
 declare const __VLS_publicComponent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    milestoneId: {
+        type: import("vue").PropType<string>;
+        default: undefined;
+    };
     isEditable: {
         type: import("vue").PropType<boolean | "only-own">;
         required: true;
@@ -34,10 +38,6 @@ declare const __VLS_publicComponent: import("vue").DefineComponent<import("vue")
         type: import("vue").PropType<ActivityType[]>;
         default: () => never[];
     };
-    milestoneId: {
-        type: import("vue").PropType<string>;
-        default: undefined;
-    };
     templateActivities: {
         type: import("vue").PropType<(Activity | ActivityFeed<import('../types/index').ActivityFeedStatus>)[]>;
         required: true;
@@ -94,6 +94,10 @@ declare const __VLS_publicComponent: import("vue").DefineComponent<import("vue")
     toast: (messageKey: string, type: "error" | "success") => void;
     createSprint: (payload: CreateSprintPayload) => void;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    milestoneId: {
+        type: import("vue").PropType<string>;
+        default: undefined;
+    };
     isEditable: {
         type: import("vue").PropType<boolean | "only-own">;
         required: true;
@@ -122,10 +126,6 @@ declare const __VLS_publicComponent: import("vue").DefineComponent<import("vue")
         type: import("vue").PropType<ActivityType[]>;
         default: () => never[];
     };
-    milestoneId: {
-        type: import("vue").PropType<string>;
-        default: undefined;
-    };
     templateActivities: {
         type: import("vue").PropType<(Activity | ActivityFeed<import('../types/index').ActivityFeedStatus>)[]>;
         required: true;
@@ -182,11 +182,11 @@ declare const __VLS_publicComponent: import("vue").DefineComponent<import("vue")
     onToast?: ((messageKey: string, type: "error" | "success") => any) | undefined;
     onCreateSprint?: ((payload: CreateSprintPayload) => any) | undefined;
 }>, {
+    milestoneId: string;
     breadcrumbs: string;
     userId: string;
     isTemplate: boolean;
     activityTypes: ActivityType[];
-    milestoneId: string;
     templateMilestones: Milestone[];
     isTaskCheckable: (task: Subtask) => boolean;
     statuses: ActivityStatus[];

package/dist/src/helpers/bulkStructureConvention.d.ts

@@ -1,11 +1,142 @@
 import type { BulkStructureConvention, BulkStructureEntityType, BulkStructureRoot } from '../types/bulkStructure';
+/**
+ * Canonical hierarchy used by the bulk insert feature.
+ *
+ * The order defines the allowed nesting:
+ *
+ * phase
+ *  milestone
+ *   activity
+ *    task
+ *
+ * Depending on where bulk insert is opened, the hierarchy starts
+ * at a different level.
+ *
+ * Examples:
+ *
+ * getLevelsForRoot('phase')
+ * -> ['phase', 'milestone', 'activity', 'task']
+ *
+ * getLevelsForRoot('milestone')
+ * -> ['milestone', 'activity', 'task']
+ *
+ * getLevelsForRoot('activity')
+ * -> ['activity', 'task']
+ */
 export declare const HIERARCHY: readonly BulkStructureEntityType[];
+/**
+ * Canonical indentation convention.
+ *
+ * One hierarchy level currently equals one space.
+ *
+ * Example:
+ *
+ * Phase 1
+ *  Milestone 1
+ *   Activity 1
+ *    Task 1
+ *
+ * The parser and the UI example generator both rely on this
+ * configuration so they always use the same indentation rules.
+ */
 export declare const INDENT_CONFIG: {
     readonly indentSize: 1;
     readonly indentCharacter: " ";
 };
+/**
+ * Returns the hierarchy levels available from a given root type.
+ *
+ * Example:
+ *
+ * getLevelsForRoot('milestone')
+ *
+ * returns:
+ *
+ * ['milestone', 'activity', 'task']
+ *
+ * This is what allows the same parser to work when bulk insert is
+ * opened from a phase, milestone or activity.
+ */
 export declare function getLevelsForRoot(rootType: BulkStructureRoot): BulkStructureEntityType[];
+/**
+ * Returns the complete convention used by the parser for a root type.
+ *
+ * Example:
+ *
+ * getBulkStructureConvention('milestone')
+ *
+ * returns:
+ *
+ * {
+ *   rootType: 'milestone',
+ *   levels: ['milestone', 'activity', 'task'],
+ *   indentSize: 1,
+ *   indentCharacter: ' '
+ * }
+ *
+ * The parser can then map indentation level to entity type:
+ *
+ * Milestone 1   -> level 0 -> milestone
+ *  Activity 1   -> level 1 -> activity
+ *   Task 1      -> level 2 -> task
+ */
 export declare function getBulkStructureConvention(rootType: BulkStructureRoot): BulkStructureConvention;
+/**
+ * Returns the string representing exactly one indentation level.
+ *
+ * With the current configuration:
+ *
+ * getIndentUnit()
+ * -> ' '
+ *
+ * If indentSize became 2:
+ *
+ * getIndentUnit()
+ * -> '  '
+ */
 export declare function getIndentUnit(convention?: Pick<BulkStructureConvention, 'indentCharacter' | 'indentSize'>): string;
+/**
+ * Returns the indentation prefix for a specific hierarchy level.
+ *
+ * With the current one-space convention:
+ *
+ * getIndentPrefix(0) -> ''
+ * getIndentPrefix(1) -> ' '
+ * getIndentPrefix(2) -> '  '
+ * getIndentPrefix(3) -> '   '
+ *
+ * This is mainly used to generate examples that follow exactly
+ * the same convention as the parser.
+ */
 export declare function getIndentPrefix(level: number, convention?: Pick<BulkStructureConvention, 'indentCharacter' | 'indentSize'>): string;
+/**
+ * Generates a textual example of the hierarchy for a given root type.
+ *
+ * This helper is responsible for hierarchy and indentation only.
+ * It does not contain user-facing labels or translations.
+ *
+ * Labels are provided by the caller through getLabel().
+ *
+ * Example:
+ *
+ * getBulkStructureExample(
+ *   'phase',
+ *   getLabel,
+ * )
+ *
+ * can output:
+ *
+ * Phase
+ *  Milestone
+ *   Activity
+ *    Task
+ *
+ * The modal can then transform that into:
+ *
+ * Phase 1
+ *  Milestone 1
+ *   Activity 1
+ *    Task 1
+ * ...
+ */
 export declare function getBulkStructureExample(rootType: BulkStructureRoot, getLabel: (type: BulkStructureEntityType) => string): string;

package/dist/src/helpers/bulkStructureParser.d.ts

@@ -1,4 +1,156 @@
 import type { BulkStructureEntityType, BulkStructureNode, BulkStructureParseResult, BulkStructureRoot } from '../types/bulkStructure';
+/**
+ * Parses bulk text into a generic hierarchical structure.
+ *
+ * The parser is responsible for:
+ *
+ * - reading indentation
+ * - determining the entity type from the indentation level
+ * - validating hierarchy
+ * - building parent/child relationships
+ *
+ * It does not generate ranks, IDs or GraphQL payloads and does not
+ * persist anything. Those responsibilities belong to later layers.
+ *
+ * Example with rootType = 'phase':
+ *
+ * Input:
+ *
+ * Phase 1
+ *  Milestone 1
+ *   Activity 1
+ *    Task 1
+ *   Activity 2
+ * Phase 2
+ *
+ * Output:
+ *
+ * {
+ *   valid: true,
+ *   errors: [],
+ *   data: [
+ *     {
+ *       type: 'phase',
+ *       name: 'Phase 1',
+ *       children: [
+ *         {
+ *           type: 'milestone',
+ *           name: 'Milestone 1',
+ *           children: [
+ *             {
+ *               type: 'activity',
+ *               name: 'Activity 1',
+ *               children: [
+ *                 {
+ *                   type: 'task',
+ *                   name: 'Task 1',
+ *                   children: []
+ *                 }
+ *               ]
+ *             },
+ *             {
+ *               type: 'activity',
+ *               name: 'Activity 2',
+ *               children: []
+ *             }
+ *           ]
+ *         }
+ *       ]
+ *     },
+ *     {
+ *       type: 'phase',
+ *       name: 'Phase 2',
+ *       children: []
+ *     }
+ *   ]
+ * }
+ *
+ * nodesAtLevel keeps track of the latest valid node at every depth.
+ *
+ * After:
+ *
+ * Phase 1
+ *  Milestone 1
+ *   Activity 1
+ *
+ * it contains:
+ *
+ * nodesAtLevel[0] = Phase 1
+ * nodesAtLevel[1] = Milestone 1
+ * nodesAtLevel[2] = Activity 1
+ *
+ * If another activity is encountered at level 2, its parent is simply
+ * nodesAtLevel[1], which is the current milestone.
+ *
+ * nodesAtLevel.length = level + 1 removes stale deeper nodes whenever
+ * the parser moves back up the hierarchy.
+ *
+ * It also allows skipped hierarchy to be detected.
+ *
+ * Example:
+ *
+ * Phase 1
+ *   Activity 1
+ *
+ * Activity 1 is level 2 but nodesAtLevel[1] does not exist, so the
+ * parser returns EXPECTED_PARENT_BEFORE for the missing milestone.
+ */
 export declare function parseBulkStructure(text: string, rootType: BulkStructureRoot): BulkStructureParseResult;
+/**
+ * Flattens the parsed hierarchy into a depth-first list.
+ *
+ * Example:
+ *
+ * Input:
+ *
+ * [
+ *   {
+ *     type: 'phase',
+ *     name: 'Phase 1',
+ *     children: [
+ *       {
+ *         type: 'milestone',
+ *         name: 'Milestone 1',
+ *         children: []
+ *       }
+ *     ]
+ *   }
+ * ]
+ *
+ * Output:
+ *
+ * [
+ *   Phase 1,
+ *   Milestone 1
+ * ]
+ *
+ * The original nodes are returned; they are not cloned.
+ *
+ * This is useful when an operation needs to inspect all nodes but does
+ * not care about the parent/child hierarchy.
+ */
 export declare function flattenBulkStructure(nodes: BulkStructureNode[]): BulkStructureNode[];
+/**
+ * Counts every entity type contained in the parsed hierarchy.
+ *
+ * Example input:
+ *
+ * Phase 1
+ *  Milestone 1
+ *   Activity 1
+ *    Task 1
+ *   Activity 2
+ *
+ * Output:
+ *
+ * {
+ *   phase: 1,
+ *   milestone: 1,
+ *   activity: 2,
+ *   task: 1
+ * }
+ *
+ * flattenBulkStructure() is used first so the counting logic does not
+ * need to know anything about hierarchy or parent/child relationships.
+ */
 export declare function countByType(nodes: BulkStructureNode[]): Record<BulkStructureEntityType, number>;

package/dist/src/helpers/bulkStructurePayload.d.ts

@@ -1,9 +1,177 @@
 import type { BulkActivityHierarchyPayload, BulkMilestoneHierarchyPayload, BulkPhaseHierarchyPayload, BulkStructureNode } from '../types/bulkStructure';
+/**
+ * Minimal shape required from existing ordered entities.
+ *
+ * Existing phases, milestones or activities are only used here
+ * to determine where new items should be appended.
+ *
+ * generateRanksAtEnd() currently expects an Ordered-compatible
+ * object, which contains both id and rank.
+ */
 interface RankedItem {
     id: string;
     rank: string;
 }
+/**
+ * Public builder used when bulk inserting activities directly
+ * into an existing milestone.
+ *
+ * Flow:
+ *
+ * parsed BulkStructureNode[]
+ * -> assign ranks after existing activities
+ * -> convert nested tasks
+ * -> BulkActivityHierarchyPayload[]
+ *
+ * Example:
+ *
+ * Parsed:
+ *
+ * Activity 1
+ *  Task 1
+ * Activity 2
+ *
+ * Existing activities:
+ *
+ * [
+ *   { id: 'existing-1', rank: '...' }
+ * ]
+ *
+ * Output:
+ *
+ * [
+ *   {
+ *     name: 'Activity 1',
+ *     rank: '<rank after existing-1>',
+ *     tasks: [
+ *       { name: 'Task 1' }
+ *     ]
+ *   },
+ *   {
+ *     name: 'Activity 2',
+ *     rank: '<next rank>'
+ *   }
+ * ]
+ */
 export declare function buildActivityHierarchy(nodes: BulkStructureNode[], existingActivities: RankedItem[]): BulkActivityHierarchyPayload[];
+/**
+ * Converts parsed milestone nodes into ranked milestone payloads.
+ *
+ * Root milestones are ranked after the milestones already present
+ * in the existing phase.
+ *
+ * Activities nested inside a newly-created milestone start with an
+ * empty existing activity list because that milestone does not yet
+ * contain any activities.
+ *
+ * Example parsed input:
+ *
+ * Milestone 1
+ *  Activity 1
+ *   Task 1
+ *  Activity 2
+ * Milestone 2
+ *
+ * Output:
+ *
+ * [
+ *   {
+ *     name: 'Milestone 1',
+ *     rank: '<next milestone rank>',
+ *     activities: [
+ *       {
+ *         name: 'Activity 1',
+ *         rank: '<first activity rank>',
+ *         tasks: [
+ *           { name: 'Task 1' }
+ *         ]
+ *       },
+ *       {
+ *         name: 'Activity 2',
+ *         rank: '<next activity rank>'
+ *       }
+ *     ]
+ *   },
+ *   {
+ *     name: 'Milestone 2',
+ *     rank: '<next milestone rank>'
+ *   }
+ * ]
+ */
 export declare function buildMilestoneHierarchy(nodes: BulkStructureNode[], existingMilestones: RankedItem[]): BulkMilestoneHierarchyPayload[];
+/**
+ * Converts parsed phase nodes into the final ranked phase hierarchy payload.
+ *
+ * Root phases are ranked after the phases already present in the project.
+ *
+ * Milestones inside a newly-created phase start with an empty existing
+ * milestone list because the new phase has no existing milestones yet.
+ *
+ * The same rule continues recursively:
+ *
+ * new phase
+ * -> new milestones
+ * -> new activities
+ * -> new tasks
+ *
+ * Only phase, milestone and activity receive ranks.
+ * Tasks do not.
+ *
+ * ------------------------------------------------------------
+ * Example
+ * ------------------------------------------------------------
+ *
+ * Parsed input:
+ *
+ * Phase 1
+ *  Milestone 1
+ *   Activity 1
+ *    Task 1
+ *   Activity 2
+ * Phase 2
+ *
+ * Output:
+ *
+ * [
+ *   {
+ *     name: 'Phase 1',
+ *     rank: '<rank after existing phases>',
+ *     milestones: [
+ *       {
+ *         name: 'Milestone 1',
+ *         rank: '<first milestone rank>',
+ *         activities: [
+ *           {
+ *             name: 'Activity 1',
+ *             rank: '<first activity rank>',
+ *             tasks: [
+ *               {
+ *                 name: 'Task 1'
+ *               }
+ *             ]
+ *           },
+ *           {
+ *             name: 'Activity 2',
+ *             rank: '<next activity rank>'
+ *           }
+ *         ]
+ *       }
+ *     ]
+ *   },
+ *   {
+ *     name: 'Phase 2',
+ *     rank: '<next phase rank>'
+ *   }
+ * ]
+ *
+ * Overall responsibility of this file:
+ *
+ * parsed generic hierarchy
+ * -> add frontend-owned ranks
+ * -> produce GraphQL/domain hierarchy payload
+ *
+ * The backend remains responsible for IDs, foreign keys, defaults,
+ * slugs, statuses and persistence.
+ */
 export declare function buildPhaseHierarchy(nodes: BulkStructureNode[], existingPhases: RankedItem[]): BulkPhaseHierarchyPayload[];
 export {};

package/dist/src/types/index.d.ts

@@ -143,6 +143,12 @@ export interface Sprint extends Entity {
     color?: string;
     active: boolean;
 }
+export interface SprintMilestone extends Entity {
+    name: string;
+    rank: string;
+    important: boolean;
+    color?: string;
+}
 export interface SprintPlanningUser {
     userId: string;
     fullName: string;
@@ -447,6 +453,7 @@ export declare const feedFilterTypes: {
     readonly project: "projectId";
     readonly assignee: "assigneeId";
     readonly sprint: "sprintId";
+    readonly milestone: "milestoneId";
 };
 export type FeedFilterTypeKeys = keyof typeof feedFilterTypes;
 export type FeedFilterType = (typeof feedFilterTypes)[FeedFilterTypeKeys];

package/dist/src/views/AoFeed.vue.d.ts

@@ -1,11 +1,15 @@
 import type { Attachment, TimeTracking } from '../types';
-import { type Activity, type ActivityDevStatus, type ActivityStatus, type ActivityType, type AddActivityFeedPayload, type AddCommentPayload, type AddFilesPayload, type AddSubtaskPayload, type ChangeFeedActivitiesPayload, type FeedFilters, type Id, type Project, type RemoveCommentPayload, type RemoveFilePayload, type Sprint, type StartTimerPayload, type Subtask, type UpdateActivityPayload, type UpdateCommentPayload, type UpdateSubtaskFieldPayload, type User } from '../types';
+import { type Activity, type ActivityDevStatus, type ActivityStatus, type ActivityType, type AddActivityFeedPayload, type AddCommentPayload, type AddFilesPayload, type AddSubtaskPayload, type ChangeFeedActivitiesPayload, type FeedFilters, type Id, type Milestone, type Project, type RemoveCommentPayload, type RemoveFilePayload, type Sprint, type StartTimerPayload, type Subtask, type UpdateActivityPayload, type UpdateCommentPayload, type UpdateSubtaskFieldPayload, type User } from '../types';
 export type FeedMode = 'standard' | 'dev';
 declare const __VLS_publicComponent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     filters: {
         type: import("vue").PropType<FeedFilters>;
         required: true;
     };
+    milestones: {
+        type: import("vue").PropType<Milestone[]>;
+        default: () => never[];
+    };
     activities: {
         type: import("vue").PropType<Activity[]>;
         required: true;
@@ -146,6 +150,10 @@ declare const __VLS_publicComponent: import("vue").DefineComponent<import("vue")
         type: import("vue").PropType<FeedFilters>;
         required: true;
     };
+    milestones: {
+        type: import("vue").PropType<Milestone[]>;
+        default: () => never[];
+    };
     activities: {
         type: import("vue").PropType<Activity[]>;
         required: true;
@@ -282,6 +290,7 @@ declare const __VLS_publicComponent: import("vue").DefineComponent<import("vue")
     "onUpdate:showsOnlyImportant"?: ((value: boolean) => any) | undefined;
     "onUpdate:showsOnlyNonAssigned"?: ((value: boolean) => any) | undefined;
 }>, {
+    milestones: Milestone[];
     project: Project;
     activityTypes: ActivityType[];
     isTaskCheckable: (task: Subtask) => boolean;

package/package.json

@@ -4,7 +4,7 @@
   "type": "module",
   "license": "CC-BY-NC-ND-4.0",
   "author": "26lights <dev@26lights.com> (https://www.26lights.com)",
-  "version": "0.42.186",
+  "version": "0.42.188",
   "workspaces": [
     "packages/*"
   ],