git-stack-cli 0.8.7 → 1.0.2

package/dist/app/Status.js

@@ -1,61 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-import { colors } from "../core/colors.js";
-import { invariant } from "../core/invariant.js";
-import { Await } from "./Await.js";
-import { StatusTable } from "./StatusTable.js";
-import { Store } from "./Store.js";
-export function Status() {
-    const argv = Store.useState((state) => state.argv);
-    invariant(argv, "argv must exist");
-    return React.createElement(Await, { fallback: null, function: () => run({ argv }) });
-}
-async function run(args) {
-    const actions = Store.getState().actions;
-    const commit_range = Store.getState().commit_range;
-    invariant(commit_range, "commit_range must exist");
-    actions.output(React.createElement(StatusTable, null));
-    let needs_rebase = false;
-    let needs_update = false;
-    for (const group of commit_range.group_list) {
-        if (group.dirty) {
-            needs_update = true;
-        }
-        if (group.pr?.state === "MERGED") {
-            needs_rebase = true;
-        }
-    }
-    for (let i = 0; i < commit_range.commit_list.length; i++) {
-        const commit = commit_range.commit_list[i];
-        const commit_pr = commit_range.pr_lookup[commit.branch_id || ""];
-        if (commit.branch_id && !commit_pr) {
-            needs_rebase = true;
-        }
-    }
-    if (args.argv.check) {
-        actions.exit(0);
-    }
-    else if (needs_rebase) {
-        Store.setState((state) => {
-            state.step = "pre-local-merge-rebase";
-        });
-    }
-    else if (needs_update) {
-        Store.setState((state) => {
-            state.step = "pre-select-commit-ranges";
-        });
-    }
-    else if (args.argv.force) {
-        Store.setState((state) => {
-            state.step = "select-commit-ranges";
-        });
-    }
-    else {
-        actions.output(React.createElement(Ink.Text, null, "\u2705 Everything up to date."));
-        actions.output(React.createElement(Ink.Text, { color: colors.gray },
-            React.createElement(Ink.Text, null, "Run with"),
-            React.createElement(Ink.Text, { bold: true, color: colors.yellow }, ` --force `),
-            React.createElement(Ink.Text, null, "to force update all pull requests.")));
-        actions.exit(0);
-    }
-}

package/dist/app/StatusTable.js

@@ -1,115 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-import { assertNever } from "../core/assertNever.js";
-import { colors } from "../core/colors.js";
-import { invariant } from "../core/invariant.js";
-import { Store } from "./Store.js";
-import { Table } from "./Table.js";
-import { Url } from "./Url.js";
-export function StatusTable() {
-    const commit_range = Store.useState((state) => state.commit_range);
-    invariant(commit_range, "commit_range must exist");
-    const row_list = [];
-    for (const group of commit_range.group_list) {
-        const row = {
-            count: "",
-            status: "NEW",
-            title: "",
-            url: "",
-        };
-        if (group.id === commit_range.UNASSIGNED) {
-            row.status = "NEW";
-            row.title = "Unassigned";
-            row.count = `0/${group.commits.length}`;
-            row.url = "";
-        }
-        else {
-            if (group.dirty) {
-                row.status = "OUTDATED";
-            }
-            else {
-                row.status = "SYNCED";
-            }
-            if (group.pr) {
-                if (group.pr.state === "MERGED") {
-                    row.status = "MERGED";
-                }
-                row.title = group.pr.title;
-                row.count = `${group.pr.commits.length}/${group.commits.length}`;
-                row.url = group.pr.url;
-            }
-            else {
-                row.title = group.title || group.id;
-                row.count = `0/${group.commits.length}`;
-            }
-        }
-        row_list.push(row);
-    }
-    return (React.createElement(Table, { data: row_list, fillColumn: "title", maxWidth: {
-            status: (v) => v + 2,
-        }, columnGap: 3, columns: {
-            status: StatusColumn,
-            count: CountColumn,
-            title: TitleColumn,
-            url: UrlColumn,
-        } }));
-}
-function StatusColumn(props) {
-    const value = props.row[props.column];
-    return (React.createElement(Ink.Text, { color: get_status_color(props.row), bold: get_status_bold(props.row) },
-        get_status_icon(props.row),
-        " ",
-        value));
-}
-function CountColumn(props) {
-    const value = props.row[props.column];
-    return React.createElement(Ink.Text, { dimColor: true }, value);
-}
-function TitleColumn(props) {
-    const value = props.row[props.column];
-    return React.createElement(Ink.Text, { wrap: "truncate-end" }, value);
-}
-function UrlColumn(props) {
-    const value = props.row[props.column];
-    return React.createElement(Url, { dimColor: true }, value);
-}
-function get_status_icon(row) {
-    switch (row.status) {
-        case "NEW":
-            return "⭑";
-        case "OUTDATED":
-            return "!";
-        case "MERGED":
-            return "↗";
-        case "SYNCED":
-            return "✔";
-        default:
-            assertNever(row.status);
-            return "?";
-        // unicode question mark in box
-    }
-}
-function get_status_color(row) {
-    switch (row.status) {
-        case "NEW":
-            return colors.yellow;
-        case "OUTDATED":
-            return colors.red;
-        case "MERGED":
-            return colors.purple;
-        case "SYNCED":
-            return colors.green;
-        default:
-            assertNever(row.status);
-            return colors.gray;
-    }
-}
-function get_status_bold(row) {
-    switch (row.status) {
-        case "NEW":
-        case "OUTDATED":
-            return true;
-        default:
-            return false;
-    }
-}

package/dist/app/Store.js

@@ -1,136 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-import { createStore, useStore } from "zustand";
-import { immer } from "zustand/middleware/immer";
-import { colors } from "../core/colors.js";
-import { Exit } from "./Exit.js";
-const BaseStore = createStore()(immer((set, get) => ({
-    argv: null,
-    ink: null,
-    cwd: null,
-    username: null,
-    repo_path: null,
-    repo_root: null,
-    master_branch: "master",
-    head: null,
-    merge_base: null,
-    branch_name: null,
-    commit_range: null,
-    commit_map: null,
-    step: "loading",
-    output: [],
-    pending_output: {},
-    pr: {},
-    actions: {
-        exit(code, clear = true) {
-            set((state) => {
-                const node = React.createElement(Exit, { clear: clear, code: code });
-                state.mutate.output(state, { node });
-            });
-        },
-        clear() {
-            get().ink?.clear();
-        },
-        unmount() {
-            get().ink?.unmount();
-        },
-        newline() {
-            set((state) => {
-                const node = "‎";
-                state.mutate.output(state, { node });
-            });
-        },
-        json(value) {
-            set((state) => {
-                const node = JSON.stringify(value, null, 2);
-                state.mutate.output(state, { node });
-            });
-        },
-        error(message) {
-            set((state) => {
-                const node = React.createElement(Ink.Text, { color: colors.red }, message);
-                state.mutate.output(state, { node });
-            });
-        },
-        output(node) {
-            set((state) => {
-                state.mutate.output(state, { node });
-            });
-        },
-        debug(node, id) {
-            if (get().actions.isDebug()) {
-                const debug = true;
-                set((state) => {
-                    if (id) {
-                        state.mutate.pending_output(state, { id, node, debug });
-                    }
-                    else {
-                        state.mutate.output(state, { node, debug });
-                    }
-                });
-            }
-        },
-        isDebug() {
-            const state = get();
-            return state.select.debug(state);
-        },
-        reset_pr() {
-            set((state) => {
-                state.pr = {};
-            });
-        },
-        set(setter) {
-            set((state) => {
-                setter(state);
-            });
-        },
-    },
-    mutate: {
-        output(state, args) {
-            switch (typeof args.node) {
-                case "boolean":
-                case "number":
-                case "string":
-                    state.output.push(React.createElement(Ink.Text, { dimColor: args.debug }, String(args.node)));
-                    return;
-            }
-            state.output.push(args.node);
-        },
-        pending_output(state, args) {
-            const { id } = args;
-            if (!id) {
-                return;
-            }
-            if (!state.pending_output[id]) {
-                state.pending_output[id] = [];
-            }
-            switch (typeof args.node) {
-                case "boolean":
-                case "number":
-                case "string": {
-                    state.pending_output[id].push(React.createElement(Ink.Text, { dimColor: args.debug }, String(args.node)));
-                    return;
-                }
-            }
-            state.pending_output[id].push(args.node);
-        },
-        end_pending_output(state, id) {
-            delete state.pending_output[id];
-        },
-    },
-    select: {
-        debug(state) {
-            return state.argv?.verbose || false;
-        },
-    },
-})));
-function useState(selector) {
-    return useStore(BaseStore, selector);
-}
-function useActions() {
-    return useState((state) => state.actions);
-}
-const getState = BaseStore.getState;
-const setState = BaseStore.setState;
-const subscribe = BaseStore.subscribe;
-export const Store = { useActions, useState, getState, setState, subscribe };

package/dist/app/Table.js

@@ -1,65 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-import { is_finite_value } from "../core/is_finite_value.js";
-export function Table(props) {
-    if (!props.data.length) {
-        return (React.createElement(Container, null,
-            React.createElement(Ink.Text, { dimColor: true }, "No data found.")));
-    }
-    const RowColumnList = Object.keys(props.columns);
-    // walk data and discover max width for each column
-    const max_col_width = {};
-    for (const col of RowColumnList) {
-        max_col_width[col] = 0;
-    }
-    for (const row of props.data) {
-        for (const col of RowColumnList) {
-            const row_col = row[col];
-            max_col_width[col] = Math.max(String(row_col).length, max_col_width[col]);
-        }
-    }
-    for (const col of RowColumnList) {
-        const maxWidth = props.maxWidth?.[col];
-        if (maxWidth) {
-            max_col_width[col] = maxWidth(max_col_width[col]);
-        }
-    }
-    const { stdout } = Ink.useStdout();
-    const available_width = stdout.columns;
-    const columnGap = is_finite_value(props.columnGap) ? props.columnGap : 2;
-    // single character breathing room to prevent url including next line via overflow
-    const breathing_room = 1;
-    if (props.fillColumn) {
-        let remaining_space = available_width;
-        for (const col of RowColumnList) {
-            // skip fill column from calculation
-            if (props.fillColumn === col) {
-                continue;
-            }
-            remaining_space -= max_col_width[col];
-        }
-        // gap * col count
-        remaining_space -= columnGap * (RowColumnList.length - 1);
-        // remove some extra space
-        remaining_space -= breathing_room;
-        if (props.fillColumn) {
-            max_col_width[props.fillColumn] = Math.min(max_col_width[props.fillColumn], remaining_space);
-        }
-    }
-    // console.debug({ available_width, max_col_width });
-    return (React.createElement(Container, null, props.data.map((row, i) => {
-        return (React.createElement(Ink.Box, { key: i, 
-            // borderStyle="round"
-            flexDirection: "row", columnGap: columnGap, width: available_width }, RowColumnList.map((column) => {
-            const ColumnComponent = props.columns[column];
-            return (React.createElement(Ink.Box, { key: String(column), width: max_col_width[column] },
-                React.createElement(ColumnComponent, { row: row, column: column })));
-        })));
-    })));
-}
-function Container(props) {
-    return (React.createElement(Ink.Box, { flexDirection: "column" },
-        React.createElement(Ink.Box, { height: 1 }),
-        props.children,
-        React.createElement(Ink.Box, { height: 1 })));
-}

package/dist/app/TextInput.js

@@ -1,51 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-import { colors } from "../core/colors.js";
-export function TextInput(props) {
-    const [value, set_value] = React.useState(get_value(props));
-    React.useEffect(function sync_value_prop() {
-        set_value(get_value(props));
-    }, [props.value]);
-    const [caret_visible, set_caret_visible] = React.useState(false);
-    React.useEffect(function blink_caret() {
-        const interval_ms = 500;
-        let timeoutId = setTimeout(tick, interval_ms);
-        function tick() {
-            set_caret_visible((visible) => !visible);
-            timeoutId = setTimeout(tick, interval_ms);
-        }
-        return function cleanup() {
-            clearTimeout(timeoutId);
-        };
-    }, []);
-    Ink.useInput((input, key) => {
-        let next_value = value;
-        // console.debug("[useInput]", { input, key });
-        if (key.backspace || key.delete) {
-            next_value = value.slice(0, -1);
-        }
-        else if (key.return) {
-            props.onSubmit?.(next_value);
-        }
-        else {
-            switch (input) {
-                case "\r":
-                    if (props.multiline) {
-                        next_value = `${value}\n`;
-                    }
-                    break;
-                default:
-                    next_value = `${value}${input}`;
-            }
-        }
-        set_value(next_value);
-        props.onChange?.(next_value);
-    });
-    // console.debug("[TextInput]", { value });
-    return (React.createElement(Ink.Box, { borderStyle: "single", minHeight: 1, borderColor: colors.yellow, borderDimColor: true },
-        React.createElement(Ink.Text, null, value || ""),
-        React.createElement(Ink.Text, { color: colors.yellow, dimColor: true, inverse: caret_visible }, " ")));
-}
-function get_value(props) {
-    return props.value || "";
-}

package/dist/app/Url copy.js

@@ -1,6 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-export function Url(props) {
-    const text_color = "#38bdf8";
-    return React.createElement(Ink.Text, { color: text_color }, props.children);
-}

package/dist/app/Url.js

@@ -1,6 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-import { colors } from "../core/colors.js";
-export function Url(props) {
-    return (React.createElement(Ink.Text, { bold: true, color: colors.blue, ...props }, props.children));
-}

package/dist/app/Waterfall.js

@@ -1,20 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-import { sleep } from "../core/sleep.js";
-import { Await } from "./Await.js";
-import { Store } from "./Store.js";
-export function Waterfall() {
-    return (React.createElement(Await, { fallback: React.createElement(Ink.Text, null, "Loading..."), function: async () => {
-            await sleep(3 * 1000);
-            Store.getState().actions.output(React.createElement(Ink.Text, null, "apple"));
-        } },
-        React.createElement(Await, { fallback: React.createElement(Ink.Text, null, "Loading..."), function: async () => {
-                await sleep(3 * 1000);
-                Store.getState().actions.output(React.createElement(Ink.Text, null, "banana"));
-            } },
-            React.createElement(Await, { fallback: React.createElement(Ink.Text, null, "Loading..."), function: async () => {
-                    await sleep(3 * 1000);
-                    Store.getState().actions.output(React.createElement(Ink.Text, null, "orange"));
-                } },
-                React.createElement(Ink.Text, null, "Waterfall")))));
-}

package/dist/app/YesNoPrompt copy.js

@@ -1,24 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-export function YesNoPrompt(props) {
-    Ink.useInput((input) => {
-        const inputLower = input.toLowerCase();
-        switch (inputLower) {
-            case "n":
-                return props.onNo();
-            case "y":
-                return props.onYes();
-        }
-    });
-    return (React.createElement(Ink.Box, { flexDirection: "column" },
-        React.createElement(Ink.Box, null,
-            React.createElement(Ink.Text, { color: "yellow" }, props.message),
-            React.createElement(Ink.Text, null, " "),
-            React.createElement(Ink.Text, { color: "#06b6d4" },
-                "(",
-                React.createElement(Ink.Text, { color: "gray" },
-                    React.createElement(Ink.Text, { color: "#22c55e", dimColor: true }, "Y"),
-                    "/",
-                    React.createElement(Ink.Text, { color: "#ef4444", dimColor: true }, "n")),
-                ")"))));
-}

package/dist/app/YesNoPrompt.js

@@ -1,40 +0,0 @@
-import * as React from "react";
-import * as Ink from "ink";
-import { colors } from "../core/colors.js";
-import { Parens } from "./Parens.js";
-export function YesNoPrompt(props) {
-    const [answer, set_answer] = React.useState("");
-    Ink.useInput((input) => {
-        const inputLower = input.toLowerCase();
-        set_answer(inputLower);
-        switch (inputLower) {
-            case "n":
-                return props.onNo();
-            case "y":
-                return props.onYes();
-        }
-    });
-    // prettier-ignore
-    const y = React.createElement(Ink.Text, { bold: true, color: colors.green }, "Y");
-    const n = React.createElement(Ink.Text, { color: colors.red }, "n");
-    let choices;
-    switch (answer) {
-        case "y":
-            choices = y;
-            break;
-        case "n":
-            choices = n;
-            break;
-        default:
-            choices = (React.createElement(React.Fragment, null,
-                y,
-                React.createElement(Ink.Text, null, "/"),
-                n));
-    }
-    return (React.createElement(Ink.Box, { flexDirection: "column" },
-        React.createElement(Ink.Box, null,
-            typeof props.message === "object" ? (props.message) : (React.createElement(Ink.Text, { color: colors.yellow }, props.message)),
-            React.createElement(Ink.Text, null, " "),
-            React.createElement(Parens, null,
-                React.createElement(Ink.Text, { color: colors.gray }, choices)))));
-}

package/dist/app/main.js

@@ -1,39 +0,0 @@
-import * as React from "react";
-import { assertNever } from "../core/assertNever.js";
-import { GithubApiError } from "./GithubApiError.js";
-import { LocalMergeRebase } from "./LocalMergeRebase.js";
-import { ManualRebase } from "./ManualRebase.js";
-import { PostRebaseStatus } from "./PostRebaseStatus.js";
-import { PreLocalMergeRebase } from "./PreLocalMergeRebase.js";
-import { PreSelectCommitRanges } from "./PreSelectCommitRanges.js";
-import { SelectCommitRanges } from "./SelectCommitRanges.js";
-import { Status } from "./Status.js";
-import { Store } from "./Store.js";
-export function Main() {
-    const step = Store.useState((state) => state.step);
-    switch (step) {
-        case "github-api-error":
-            return React.createElement(GithubApiError, null);
-        case "loading":
-            return null;
-        case "status":
-            return React.createElement(Status, null);
-        case "local-merge-rebase":
-            return React.createElement(LocalMergeRebase, null);
-        case "pre-local-merge-rebase":
-            return React.createElement(PreLocalMergeRebase, null);
-        case "pre-select-commit-ranges":
-            return React.createElement(PreSelectCommitRanges, null);
-        case "select-commit-ranges":
-            return React.createElement(SelectCommitRanges, null);
-        case "manual-rebase":
-            return React.createElement(ManualRebase, null);
-        case "manual-rebase-no-sync":
-            return React.createElement(ManualRebase, { skipSync: true });
-        case "post-rebase-status":
-            return React.createElement(PostRebaseStatus, null);
-        default:
-            assertNever(step);
-            return null;
-    }
-}

package/dist/cli.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-import * as React from "react";
-import * as Ink from "ink";
-import { App } from "./app/App.js";
-import { command } from "./command.js";
-const argv = await command();
-const ink = {};
-const app = Ink.render(React.createElement(App, { argv: argv, ink: ink }));
-Object.assign(ink, app);

package/dist/command.js

@@ -1,60 +0,0 @@
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-export async function command() {
-    // https://yargs.js.org/docs/#api-reference-optionkey-opt
-    return (yargs(hideBin(process.argv))
-        .usage("Usage: git stack [options]")
-        .option("force", {
-        type: "boolean",
-        alias: ["f"],
-        default: false,
-        description: "Force sync even if no changes are detected",
-    })
-        .option("check", {
-        type: "boolean",
-        alias: ["c"],
-        default: false,
-        description: "Print status table without syncing",
-    })
-        .option("verify", {
-        type: "boolean",
-        default: true,
-        description: "Skip git hooks such as pre-commit and pre-push",
-    })
-        .option("verbose", {
-        type: "boolean",
-        alias: ["v"],
-        default: false,
-        description: "Print more detailed logs for debugging internals",
-    })
-        .option("update", {
-        type: "boolean",
-        alias: ["u"],
-        default: false,
-        description: "Check for updates",
-    })
-        .option("branch", {
-        type: "string",
-        alias: ["b"],
-        description: `Set the master branch name, defaults to "master" (or "main" if "master" is not found)`,
-    })
-        .option("write-state-json", {
-        hidden: true,
-        type: "boolean",
-        default: false,
-        description: "Write state to local json file for debugging",
-    })
-        .option("mock-metadata", {
-        hidden: true,
-        type: "boolean",
-        default: false,
-        description: "Mock local store metadata for testing",
-    })
-        // do not wrap to 80 columns (yargs default)
-        // .wrap(yargs().terminalWidth()) will fill terminal (maximuize)
-        .wrap(null)
-        // disallow unknown options
-        .strict()
-        .version()
-        .help("help").argv);
-}