feat(task): add baseMixin support in TaskTypes

- Add baseMixin field to TaskType interface (plugins/task/src/index.ts)
- Add @prop decorator for baseMixin in model (models/task/src/index.ts)
- Modify mixin creation logic to use baseMixin when provided (plugins/task/src/utils.ts)
- Add validateMixinHierarchy function for inheritance validation
- Create MixinSelector.svelte component for UI selection
- Add i18n strings for BaseMixin, BaseMixinDescription, NoBaseMixin

This allows TaskTypes to inherit attributes from existing mixins while maintaining backwards compatibility.

Signed-off-by: Luis Rosas <luisrosasx@users.noreply.github.com>

Author: luisrosasx

models/task/src/index.ts

@@ -210,6 +210,9 @@ export class TTaskType extends TDoc implements TaskType {
   @Prop(ArrOf(TypeRef(task.class.TaskType)), getEmbeddedLabel('Parent'))
     allowedAsChildOf!: Ref<TaskType>[] // In case of specified, task type is for sub-tasks
 
+  @Prop(TypeRef(core.class.Mixin), getEmbeddedLabel('Base Mixin'))
+    baseMixin?: Ref<Mixin<Task>> // Existing mixin to inherit attributes from
+
   @Prop(TypeRef(core.class.Class), getEmbeddedLabel('Task class'))
     ofClass!: Ref<Class<Task>> // Base class for task
 

plugins/task-assets/lang/en.json

@@ -79,6 +79,9 @@
     "StatusChange": "Status changed",
     "TaskCreated": "Task created",
     "TaskType": "Task type",
+    "BaseMixin": "Base Mixin",
+    "BaseMixinDescription": "Inherit attributes from an existing mixin",
+    "NoBaseMixin": "None (create new)",
     "ManageProjects": "Project types",
     "Export": "Export",
     "CreateProjectType": "Create project type",

plugins/task-resources/src/components/taskTypes/MixinSelector.svelte

@@ -0,0 +1,82 @@
+<script lang="ts">
+  import { Class, Mixin, Ref } from '@hcengineering/core'
+  import { Task } from '@hcengineering/task'
+  import { ButtonMenu, Label } from '@hcengineering/ui'
+  import { createEventDispatcher } from 'svelte'
+  import { getClient } from '@hcengineering/presentation'
+  import plugin from '../../plugin'
+
+  export let baseClass: Ref<Class<Task>>
+  export let value: Ref<Mixin<Task>> | undefined = undefined
+  export let readonly = false
+  export let buttonKind: 'primary' | 'secondary' | 'tertiary' | 'negative' = 'secondary'
+  export let buttonSize: 'large' | 'medium' | 'small' = 'large'
+
+  const dispatch = createEventDispatcher()
+  const client = getClient()
+  const hierarchy = client.getHierarchy()
+
+  // Find all mixins that derive from baseClass
+  function getAvailableMixins (): Array<{ id: string; label: string }> {
+    const result: Array<{ id: string; label: string }> = [
+      { id: '', label: 'None (create new)' }
+    ]
+
+    try {
+      const descendants = hierarchy.getDescendants(baseClass)
+      for (const descendant of descendants) {
+        const cls = hierarchy.getClass(descendant)
+        if (cls.kind === 'mixin' && descendant !== baseClass) {
+          result.push({
+            id: descendant as string,
+            label: cls.label ?? descendant
+          })
+        }
+      }
+    } catch (e) {
+      console.error('Error getting available mixins:', e)
+    }
+
+    return result
+  }
+
+  function handleSelect (evt: CustomEvent<string>): void {
+    if (evt.detail !== undefined) {
+      value = evt.detail === '' ? undefined : (evt.detail as Ref<Mixin<Task>>)
+      dispatch('change', value)
+    }
+  }
+
+  $: items = getAvailableMixins()
+  $: selected = items.find((it) => it.id === (value ?? ''))
+</script>
+
+<div class="mixin-selector">
+  <Label label={plugin.string.BaseMixin} />
+  {#if readonly}
+    {#if selected}
+      <span class="selected-value">{selected.label}</span>
+    {/if}
+  {:else}
+    <ButtonMenu
+      selected={value ?? ''}
+      {items}
+      label={selected?.label ?? plugin.string.NoBaseMixin}
+      kind={buttonKind}
+      size={buttonSize}
+      on:selected={handleSelect}
+    />
+  {/if}
+</div>
+
+<style lang="scss">
+  .mixin-selector {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .selected-value {
+    color: var(--theme-content-color);
+  }
+</style>

plugins/task-resources/src/plugin.ts

@@ -89,7 +89,10 @@ export default mergeIds(taskId, task, {
     RenameStatus: '' as IntlString,
     UpdateTasksStatusRequest: '' as IntlString,
     TaskTypes: '' as IntlString,
-    Collections: '' as IntlString
+    Collections: '' as IntlString,
+    BaseMixin: '' as IntlString,
+    BaseMixinDescription: '' as IntlString,
+    NoBaseMixin: '' as IntlString
   },
   status: {
     AssigneeRequired: '' as IntlString

plugins/task/src/index.ts

@@ -120,6 +120,9 @@ export interface TaskType extends Doc, IconProps {
   // Specify if task is allowed to be used as subtask of following tasks.
   allowedAsChildOf?: Ref<TaskType>[]
 
+  // Existing mixin to inherit attributes from (optional)
+  baseMixin?: Ref<Mixin<Task>>
+
   ofClass: Ref<Class<Task>> // Base class for task
   targetClass: Ref<Class<Task>> // Class or Mixin mixin to hold all user defined attributes.
 

plugins/task/src/utils.ts

@@ -21,6 +21,7 @@ import core, {
   DocumentQuery,
   Hierarchy,
   IdMap,
+  Mixin,
   Ref,
   Status,
   TxOperations,
@@ -330,11 +331,14 @@ async function createTaskTypes (
       const targetClassId = `${taskId}:type:mixin` as Ref<Class<Task>>
       tdata.targetClass = targetClassId
 
+      // Use baseMixin if provided, otherwise extend ofClass directly
+      const extendsClass = data.baseMixin ?? data.ofClass
+
       await client.createDoc(
         core.class.Mixin,
         core.space.Model,
         {
-          extends: data.ofClass,
+          extends: extendsClass,
           kind: ClassifierKind.MIXIN,
           label: ofClassClass.label,
           icon: ofClassClass.icon
@@ -353,3 +357,17 @@ async function createTaskTypes (
   }
   return hasUpdates
 }
+
+/**
+ * @public
+ * Validates that a baseMixin is compatible with the ofClass hierarchy.
+ * Returns true if baseMixin is undefined or if it derives from ofClass.
+ */
+export function validateMixinHierarchy (
+  hierarchy: Hierarchy,
+  baseMixin: Ref<Mixin<Task>> | undefined,
+  ofClass: Ref<Class<Task>>
+): boolean {
+  if (baseMixin === undefined) return true
+  return hierarchy.isDerived(baseMixin, ofClass)
+}