simian 0.1.1

A command-line tool for exploring and implementing Machine Learning algorithms in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

import _ from 'lodash'
import { Columns2 } from 'lucide-react'
import { nanoid } from 'nanoid'

import { blockApply } from '@/ui/editor/utils'

import { SlashAddonCommandFactory } from '../types'

export const column: SlashAddonCommandFactory<'column', 'text'> = ({
  t,
  ...ctx
}) => ({
  id: 'column',
  icon: <Columns2 className="w-8 h-8" />,
  group: 'text',
  title: t.title('@editor.@slash.{n}_columns', { n: 2 }),
  run: () =>
    blockApply({
      ...ctx,
      focus: 'block',
      afterElement: ctx.editor.hasAddon('paragraph')
        ? () => ({
            id: nanoid(),
            type: 'paragraph',
            children: [{ text: '' }],
          })
        : undefined,
      block: {
        id: nanoid(),
        children: [
          {
            id: nanoid(),
            children: ctx.editor.hasAddon('paragraph')
              ? [
                  {
                    id: nanoid(),
                    children: [{ text: '' }],
                    type: 'paragraph',
                  },
                ]
              : [],
            flex: {
              base: '1fr',
              sm: '1fr',
              md: '1fr',
              lg: '1fr',
              xl: '1fr',
            },
            type: 'column-slot',
          },
          {
            id: nanoid(),
            children: ctx.editor.hasAddon('paragraph')
              ? [
                  {
                    id: nanoid(),
                    children: [{ text: '' }],
                    type: 'paragraph',
                  },
                ]
              : [],
            flex: {
              base: '1fr',
              sm: '1fr',
              md: '1fr',
              lg: '1fr',
              xl: '1fr',
            },
            type: 'column-slot',
          },
        ],
        gap: 24,
        type: 'column',
      },
      patchBlock: (columnBlock, existingChildren) => {
        // Clone the block to avoid mutating the original template
        const newBlock = _.cloneDeep(columnBlock)

        // Target the first slot
        const firstSlot =
          newBlock.type == 'column' ? newBlock.children[0] : null

        // If the existing content is just a paragraph, we place its children
        // into a new paragraph inside the slot, OR just move the whole node.
        if (firstSlot) {
          firstSlot.children = [
            {
              id: nanoid(),
              type: 'paragraph',
               
              children: existingChildren as any,
            },
          ]
        }

        return newBlock
      },
    }),
})

export const slashCommands = [column]
export type ColumnSlashCommandIds = ReturnType<
  (typeof slashCommands)[number]
>['id']