Action

Import Taskpaper-formatted Draft into OmniOutliner

Posted by unlocked2412, Last update 12 days ago

This Drafts 5 action imports a TaskPaper-formatted Draft into OmniOutliner using the new OmniJS API.

Steps

  • script

    const options = {
    	content: draft.content
    }
  • script

    // DRAFTS JS CODE --------------------------------------------------------
    const draftsJSContext = () => {
        // main :: IO ()
        const main = () => {
            return runOmniJSWithArgsFromDrafts(
                'omnioutliner://localhost/omnijs-run',
                omniJSContext,
                options
            )
        };
    
        // OMNI JS CODE ---------------------------------------
        const omniJSContext = opts => {
            // main :: IO ()
            const main = () => {
                const forest = compose(
                    map(
                        compose(
                            fmapTree(
                                x => ({
                                    topic: x.text,
                                    note: x.note
                                })
                            ),
                            treeWithNotes
                        )
                    ),
                    forestFromTaskPaperString
                )(opts.content)
    
                return Document.makeNewAndShow(
                    doc => ooRowsFromForest(doc.outline.rootItem)(
                        forest
                    )
                )
            };
    
            // GENERIC FUNCTIONS ----------------------------------
            // https://github.com/RobTrew/prelude-jxa
            // JS Prelude --------------------------------------------------
            // Just :: a -> Maybe a
            const Just = x => ({
                type: 'Maybe',
                Nothing: false,
                Just: x
            });
    
            // Node :: a -> [Tree a] -> Tree a
            const Node = v =>
                // Constructor for a Tree node which connects a
                // value of some kind to a list of zero or
                // more child trees.
                xs => ({
                    type: 'Node',
                    root: v,
                    nest: xs || []
                });
    
            // Nothing :: Maybe a
            const Nothing = () => ({
                type: 'Maybe',
                Nothing: true,
            });
    
            // Tuple (,) :: a -> b -> (a, b)
            const Tuple = a =>
                b => ({
                    type: 'Tuple',
                    '0': a,
                    '1': b,
                    length: 2
                });
    
            // compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
            const compose = (...fs) =>
                // A function defined by the right-to-left
                // composition of all the functions in fs.
                fs.reduce(
                    (f, g) => x => f(g(x)),
                    x => x
                );
    
            // div :: Int -> Int -> Int
            const div = x =>
                y => Math.floor(x / y);
    
            // eq (==) :: Eq a => a -> a -> Bool
            const eq = a =>
                // True when a and b are equivalent in the terms
                // defined below for their shared data type.
                b => {
                    const t = typeof a;
                    return t !== typeof b ? (
                        false
                    ) : 'object' !== t ? (
                        'function' !== t ? (
                            a === b
                        ) : a.toString() === b.toString()
                    ) : (() => {
                        const kvs = Object.entries(a);
                        return kvs.length !== Object.keys(b).length ? (
                            false
                        ) : kvs.every(([k, v]) => eq(v)(b[k]));
                    })();
                };
    
            // filter :: (a -> Bool) -> [a] -> [a]
            const filter = p =>
                // The elements of xs which match
                // the predicate p.
                xs => [...xs].filter(p);
    
            // findIndices :: (a -> Bool) -> [a] -> [Int]
            // findIndices :: (String -> Bool) -> String -> [Int]
            const findIndices = p =>
                xs => (
                    ys => ys.flatMap((y, i) => p(y, i, ys) ? (
                        [i]
                    ) : [])
                )([...xs])
    
            // first :: (a -> b) -> ((a, c) -> (b, c))
            const first = f =>
                // A simple function lifted to one which applies
                // to a tuple, transforming only its first item.
                xy => Tuple(f(xy[0]))(
                    xy[1]
                );
    
            // flip :: (a -> b -> c) -> b -> a -> c
            const flip = op =>
                // The binary function op with its arguments reversed.
                1 < op.length ? (
                    (a, b) => op(b, a)
                ) : (x => y => op(y)(x));
    
            // fmapTree :: (a -> b) -> Tree a -> Tree b
            const fmapTree = f => {
                // A new tree. The result of a structure-preserving
                // application of f to each root in the existing tree.
                const go = tree => Node(f(tree.root))(
                    tree.nest.map(go)
                );
                return go;
            };
    
            // foldTree :: (a -> [b] -> b) -> Tree a -> b
            const foldTree = f => {
                // The catamorphism on trees. A summary
                // value obtained by a depth-first fold.
                const go = tree => f(tree.root)(
                    tree.nest.map(go)
                );
                return go;
            };
    
            // fst :: (a, b) -> a
            const fst = tpl =>
                // First member of a pair.
                tpl[0];
    
            // isSpace :: Char -> Bool
            const isSpace = c =>
                // True if c is a white space character.
                /\s/.test(c);
    
            // length :: [a] -> Int
            const length = xs =>
                // Returns Infinity over objects without finite
                // length. This enables zip and zipWith to choose
                // the shorter argument when one is non-finite,
                // like cycle, repeat etc
                'GeneratorFunction' !== xs.constructor.constructor.name ? (
                    xs.length
                ) : Infinity;
    
            // lines :: String -> [String]
            const lines = s =>
                // A list of strings derived from a single
                // newline-delimited string.
                0 < s.length ? (
                    s.split(/[\r\n]/)
                ) : [];
    
            // list :: StringOrArrayLike b => b -> [a]
            const list = xs =>
                // xs itself, if it is an Array,
                // or an Array derived from xs.
                Array.isArray(xs) ? (
                    xs
                ) : Array.from(xs || []);
    
            // map :: (a -> b) -> [a] -> [b]
            const map = f =>
                // The list obtained by applying f
                // to each element of xs.
                // (The image of xs under f).
                xs => [...xs].map(f);
    
            // matching :: [a] -> (a -> Int -> [a] -> Bool)
            const matching = pat => {
                // A sequence-matching function for findIndices etc
                // findIndices(matching([2, 3]), [1, 2, 3, 1, 2, 3])
                // -> [1, 4]
                const
                    lng = pat.length,
                    bln = 0 < lng,
                    h = bln ? pat[0] : undefined;
                return x => i => src =>
                    bln && h == x && eq(pat)(
                        src.slice(i, lng + i)
                    );
            };
    
            // minimum :: Ord a => [a] -> a
            const minimum = xs => (
                // The least value of xs.
                ys => 0 < ys.length ? (
                    ys.slice(1)
                    .reduce((a, y) => y < a ? y : a, ys[0])
                ) : undefined
            )(list(xs));
    
            // nest :: Tree a -> [a]
            const nest = tree => {
                // Allowing for lazy (on-demand) evaluation.
                // If the nest turns out to be a function –
                // rather than a list – that function is applied
                // here to the root, and returns a list.
                const xs = tree.nest;
                return 'function' !== typeof xs ? (
                    xs
                ) : xs(root(x));
            };
    
            // Derive a function from the name of a JS infix operator
            // op :: String -> (a -> a -> b)
            const op = strOp =>
                eval(`(a, b) => a ${strOp} b`);
    
            // partition :: (a -> Bool) -> [a] -> ([a], [a])
            const partition = p =>
                // A tuple of two lists - those elements in 
                // xs which match p, and those which don't.
                xs => list(xs).reduce(
                    (a, x) => p(x) ? (
                        Tuple(a[0].concat(x))(a[1])
                    ) : Tuple(a[0])(a[1].concat(x)),
                    Tuple([])([])
                );
    
            // root :: Tree a -> a
            const root = tree => tree.root;
    
            // snd :: (a, b) -> b
            const snd = tpl => tpl[1];
    
            // span, applied to a predicate p and a list xs, returns a tuple of xs of 
            // elements that satisfy p and second element is the remainder of the list:
            //
            // > span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
            // > span (< 9) [1,2,3] == ([1,2,3],[])
            // > span (< 0) [1,2,3] == ([],[1,2,3])
            //
            // span p xs is equivalent to (takeWhile p xs, dropWhile p xs) 
            // span :: (a -> Bool) -> [a] -> ([a], [a])
            const span = p =>
                // Longest prefix of xs consisting of elements which
                // all satisfy p, tupled with the remainder of xs.
                xs => {
                    const
                        ys = 'string' !== typeof xs ? (
                            list(xs)
                        ) : xs,
                        iLast = ys.length - 1;
                    return splitAt(
                        until(
                            i => iLast < i || !p(ys[i])
                        )(i => 1 + i)(0)
                    )(ys);
                };
    
            // splitArrow (***) :: (a -> b) -> (c -> d) -> ((a, c) -> (b, d))
            const splitArrow = f =>
                // The functions f and g combined in a single function
                // from a tuple (x, y) to a tuple of (f(x), g(y))
                // (see bimap)
                g => tpl => Tuple(f(tpl[0]))(
                    g(tpl[1])
                );
    
            // splitAt :: Int -> [a] -> ([a], [a])
            const splitAt = n =>
                xs => Tuple(xs.slice(0, n))(
                    xs.slice(n)
                );
    
            // splitOn :: [a] -> [a] -> [[a]]
            // splitOn :: String -> String -> [String]
            const splitOn = pat => src =>
                /* A list of the strings delimited by
                   instances of a given pattern in s. */
                ('string' === typeof src) ? (
                    src.split(pat)
                ) : (() => {
                    const
                        lng = pat.length,
                        tpl = findIndices(matching(pat))(src).reduce(
                            (a, i) => Tuple(
                                fst(a).concat([src.slice(snd(a), i)])
                            )(lng + i),
                            Tuple([])(0),
                        );
                    return fst(tpl).concat([src.slice(snd(tpl))]);
                })();
    
            // take :: Int -> [a] -> [a]
            // take :: Int -> String -> String
            const take = n =>
                // The first n elements of a list,
                // string of characters, or stream.
                xs => 'GeneratorFunction' !== xs
                .constructor.constructor.name ? (
                    xs.slice(0, n)
                ) : [].concat.apply([], Array.from({
                    length: n
                }, () => {
                    const x = xs.next();
                    return x.done ? [] : [x.value];
                }));
    
            // uncons :: [a] -> Maybe (a, [a])
            const uncons = xs => {
                // Just a tuple of the head of xs and its tail, 
                // Or Nothing if xs is an empty list.
                const lng = length(xs);
                return (0 < lng) ? (
                    Infinity > lng ? (
                        Just(Tuple(xs[0])(xs.slice(1))) // Finite list
                    ) : (() => {
                        const nxt = take(1)(xs);
                        return 0 < nxt.length ? (
                            Just(Tuple(nxt[0])(xs))
                        ) : Nothing();
                    })() // Lazy generator
                ) : Nothing();
            };
    
            // unlines :: [String] -> String
            const unlines = xs =>
                // A single string formed by the intercalation
                // of a list of strings with the newline character.
                xs.join('\n');
    
            // until :: (a -> Bool) -> (a -> a) -> a -> a
            const until = p => f => x => {
                let v = x;
                while (!p(v)) v = f(v);
                return v;
            };
    
            // JS Trees ----------------------------------------------------
            // forestFromLineIndents :: [(Int, String)] -> [Tree String]
            const forestFromLineIndents = tuples => {
                const go = xs =>
                    0 < xs.length ? (() => {
                        const [n, s] = Array.from(xs[0]);
                        // Lines indented under this line,
                        // tupled with all the rest.
                        const [firstTreeLines, rest] = Array.from(
                            span(x => n < x[0])(xs.slice(1))
                        );
                        // This first tree, and then the rest.
                        return [
                            Node({
                                body: s,
                                depth: n
                            })(go(firstTreeLines))
                        ].concat(go(rest));
                    })() : [];
                return go(tuples);
            };
    
            // forestFromTaskPaperString :: String -> Tree Dict
            const forestFromTaskPaperString = s => {
                const
                    tpItemType = x => x.startsWith('- ') ? ({
                        text: x.slice(2),
                        type: 'task'
                    }) : x.endsWith(':') ? ({
                        text: x.slice(0, -1),
                        type: 'project'
                    }) : {
                        text: x,
                        type: 'note'
                    },
                    tpTagDict = xs => xs.reduce((a, x) => {
                        const kv = x.split('(');
                        return Object.assign(a, {
                            [kv[0]]: 1 < kv.length ? (
                                kv[1].split(')')[0]
                            ) : ''
                        })
                    }, {}),
                    tpParse = dct => {
                        const
                            pair = splitArrow(tpItemType)(tpTagDict)(
                                uncons(
                                    splitOn(' @')(dct.body)
                                ).Just
                            );
                        return Object.assign({}, dct, pair[0], {
                            tags: pair[1]
                        });
                    };
                return compose(
                    map(fmapTree(tpParse)),
                    forestFromLineIndents,
                    indentLevelsFromLines,
                    filter(Boolean),
                    lines
                )(s);
            };
    
            // indentLevelsFromLines :: [String] -> [(Int, String)]
            const indentLevelsFromLines = xs => {
                const
                    indentTextPairs = xs.map(compose(
                        first(length),
                        span(isSpace)
                    )),
                    indentUnit = minimum(
                        indentTextPairs.flatMap(pair => {
                            const w = fst(pair);
                            return 0 < w ? [w] : [];
                        })
                    );
                return indentTextPairs.map(
                    first(flip(div)(indentUnit))
                );
            };
    
            // indentedLinesFromTrees :: String -> (a -> String) ->
            //      [Tree a] -> [String]
            const indentedLinesFromTrees = strTab => f => trees => {
                const go = indent => node => [indent + f(node)]
                    .concat(node.nest.flatMap(go(strTab + indent)));
                return trees.flatMap(go(''));
            };
    
            // treeWithNotes :: Tree Dict -> Tree Dict
            const treeWithNotes = foldTree(item => subtrees => {
                const [withNotes, withoutNotes] = Array.from(
                    partition(
                        child => child.root.type === 'note'
                    )(subtrees)
                );
                return Node(
                    Object.assign({},
                        item, {
                            note: compose(
                                unlines,
                                indentedLinesFromTrees('\t')(
                                    compose(
                                        x => x.text,
                                        root
                                    )
                                )
                            )(withNotes)
                        }
                    )
                )(
                    withoutNotes
                )
            })
    
            // OmniOutliner OmniJS -----------------------------------------
            // ooRowsFromForest :: OO Item -> [Tree] -> [OO Item]
            const ooRowsFromForest = parent => trees => {
                const go = parent => tree => {
                    const
                        item = parent.addChild(
                            null,
                            x => Object.assign(
                                x, tree.root
                            )
                        );
                    return (
                        tree.nest.map(go(item)),
                        item
                    );
                };
                return trees.map(go(parent));
            };
    
            // MAIN -----------------------------------------
            return main()
        };
    
        // runOmniJSWithArgsFromDrafts :: URL String -> Function -> [...OptionalArgs] -> a
        function runOmniJSWithArgsFromDrafts(baseURL, f) {
            const
                strCode = encodeURIComponent(
                    `(${f})(${Array.from(arguments)
                    .slice(2).map(JSON.stringify)})`
                ),
                strURL = `${baseURL}?script=${strCode}`;
            return app.openURL(strURL)
    }
    
        return main()
    };
    draftsJSContext()

Options

  • After Success Default
    Notification Info
    Log Level Info
Items available in the Drafts Directory are uploaded by community members. Use appropriate caution reviewing downloaded items before use.