526 lines
21 KiB
Rust
526 lines
21 KiB
Rust
use std::{sync::Arc, time::Duration};
|
|
|
|
use crate::{ZED_PREDICT_DATA_COLLECTION_CHOICE, onboarding_event};
|
|
use anyhow::Context as _;
|
|
use client::{Client, UserStore, zed_urls};
|
|
use db::kvp::KEY_VALUE_STORE;
|
|
use fs::Fs;
|
|
use gpui::{
|
|
Animation, AnimationExt as _, ClickEvent, DismissEvent, Entity, EventEmitter, FocusHandle,
|
|
Focusable, MouseDownEvent, Render, ease_in_out, svg,
|
|
};
|
|
use language::language_settings::{AllLanguageSettings, EditPredictionProvider};
|
|
use settings::{Settings, update_settings_file};
|
|
use ui::{Checkbox, TintColor, prelude::*};
|
|
use util::ResultExt;
|
|
use workspace::{ModalView, Workspace, notifications::NotifyTaskExt};
|
|
|
|
/// Introduces user to Zed's Edit Prediction feature and terms of service
|
|
pub struct ZedPredictModal {
|
|
user_store: Entity<UserStore>,
|
|
client: Arc<Client>,
|
|
fs: Arc<dyn Fs>,
|
|
focus_handle: FocusHandle,
|
|
sign_in_status: SignInStatus,
|
|
terms_of_service: bool,
|
|
data_collection_expanded: bool,
|
|
data_collection_opted_in: bool,
|
|
}
|
|
|
|
#[derive(PartialEq, Eq)]
|
|
enum SignInStatus {
|
|
/// Signed out or signed in but not from this modal
|
|
Idle,
|
|
/// Authentication triggered from this modal
|
|
Waiting,
|
|
/// Signed in after authentication from this modal
|
|
SignedIn,
|
|
}
|
|
|
|
impl ZedPredictModal {
|
|
pub fn toggle(
|
|
workspace: &mut Workspace,
|
|
user_store: Entity<UserStore>,
|
|
client: Arc<Client>,
|
|
fs: Arc<dyn Fs>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Workspace>,
|
|
) {
|
|
workspace.toggle_modal(window, cx, |_window, cx| Self {
|
|
user_store,
|
|
client,
|
|
fs,
|
|
focus_handle: cx.focus_handle(),
|
|
sign_in_status: SignInStatus::Idle,
|
|
terms_of_service: false,
|
|
data_collection_expanded: false,
|
|
data_collection_opted_in: false,
|
|
});
|
|
}
|
|
|
|
fn view_terms(&mut self, _: &ClickEvent, _: &mut Window, cx: &mut Context<Self>) {
|
|
cx.open_url("https://zed.dev/terms-of-service");
|
|
cx.notify();
|
|
|
|
onboarding_event!("ToS Link Clicked");
|
|
}
|
|
|
|
fn view_blog(&mut self, _: &ClickEvent, _: &mut Window, cx: &mut Context<Self>) {
|
|
cx.open_url("https://zed.dev/blog/edit-prediction");
|
|
cx.notify();
|
|
|
|
onboarding_event!("Blog Link clicked");
|
|
}
|
|
|
|
fn inline_completions_doc(&mut self, _: &ClickEvent, _: &mut Window, cx: &mut Context<Self>) {
|
|
cx.open_url("https://zed.dev/docs/configuring-zed#disabled-globs");
|
|
cx.notify();
|
|
|
|
onboarding_event!("Docs Link Clicked");
|
|
}
|
|
|
|
fn accept_and_enable(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
|
|
let task = self
|
|
.user_store
|
|
.update(cx, |this, cx| this.accept_terms_of_service(cx));
|
|
let fs = self.fs.clone();
|
|
|
|
cx.spawn(async move |this, cx| {
|
|
task.await?;
|
|
|
|
let mut data_collection_opted_in = false;
|
|
this.update(cx, |this, _cx| {
|
|
data_collection_opted_in = this.data_collection_opted_in;
|
|
})
|
|
.ok();
|
|
|
|
KEY_VALUE_STORE
|
|
.write_kvp(
|
|
ZED_PREDICT_DATA_COLLECTION_CHOICE.into(),
|
|
data_collection_opted_in.to_string(),
|
|
)
|
|
.await
|
|
.log_err();
|
|
|
|
// Make sure edit prediction provider setting is using the new key
|
|
let settings_path = paths::settings_file().as_path();
|
|
let settings_path = fs.canonicalize(settings_path).await.with_context(|| {
|
|
format!("Failed to canonicalize settings path {:?}", settings_path)
|
|
})?;
|
|
|
|
if let Some(settings) = fs.load(&settings_path).await.log_err() {
|
|
if let Some(new_settings) =
|
|
migrator::migrate_edit_prediction_provider_settings(&settings)?
|
|
{
|
|
fs.atomic_write(settings_path, new_settings).await?;
|
|
}
|
|
}
|
|
|
|
this.update(cx, |this, cx| {
|
|
update_settings_file::<AllLanguageSettings>(this.fs.clone(), cx, move |file, _| {
|
|
file.features
|
|
.get_or_insert(Default::default())
|
|
.edit_prediction_provider = Some(EditPredictionProvider::Zed);
|
|
});
|
|
|
|
cx.emit(DismissEvent);
|
|
})
|
|
})
|
|
.detach_and_notify_err(window, cx);
|
|
|
|
onboarding_event!(
|
|
"Enable Clicked",
|
|
data_collection_opted_in = self.data_collection_opted_in,
|
|
);
|
|
}
|
|
|
|
fn sign_in(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
|
|
let client = self.client.clone();
|
|
self.sign_in_status = SignInStatus::Waiting;
|
|
|
|
cx.spawn(async move |this, cx| {
|
|
let result = client
|
|
.authenticate_and_connect(true, &cx)
|
|
.await
|
|
.into_response();
|
|
|
|
let status = match result {
|
|
Ok(_) => SignInStatus::SignedIn,
|
|
Err(_) => SignInStatus::Idle,
|
|
};
|
|
|
|
this.update(cx, |this, cx| {
|
|
this.sign_in_status = status;
|
|
onboarding_event!("Signed In");
|
|
cx.notify()
|
|
})?;
|
|
|
|
result
|
|
})
|
|
.detach_and_notify_err(window, cx);
|
|
|
|
onboarding_event!("Sign In Clicked");
|
|
}
|
|
|
|
fn cancel(&mut self, _: &menu::Cancel, _: &mut Window, cx: &mut Context<Self>) {
|
|
cx.emit(DismissEvent);
|
|
}
|
|
}
|
|
|
|
impl EventEmitter<DismissEvent> for ZedPredictModal {}
|
|
|
|
impl Focusable for ZedPredictModal {
|
|
fn focus_handle(&self, _cx: &App) -> FocusHandle {
|
|
self.focus_handle.clone()
|
|
}
|
|
}
|
|
|
|
impl ModalView for ZedPredictModal {}
|
|
|
|
impl ZedPredictModal {
|
|
fn render_data_collection_explanation(&self, cx: &Context<Self>) -> impl IntoElement {
|
|
fn label_item(label_text: impl Into<SharedString>) -> impl Element {
|
|
Label::new(label_text).color(Color::Muted).into_element()
|
|
}
|
|
|
|
fn info_item(label_text: impl Into<SharedString>) -> impl Element {
|
|
h_flex()
|
|
.items_start()
|
|
.gap_2()
|
|
.child(
|
|
div()
|
|
.mt_1p5()
|
|
.child(Icon::new(IconName::Check).size(IconSize::XSmall)),
|
|
)
|
|
.child(div().w_full().child(label_item(label_text)))
|
|
}
|
|
|
|
fn multiline_info_item<E1: Into<SharedString>, E2: IntoElement>(
|
|
first_line: E1,
|
|
second_line: E2,
|
|
) -> impl Element {
|
|
v_flex()
|
|
.child(info_item(first_line))
|
|
.child(div().pl_5().child(second_line))
|
|
}
|
|
|
|
v_flex()
|
|
.mt_2()
|
|
.p_2()
|
|
.rounded_sm()
|
|
.bg(cx.theme().colors().editor_background.opacity(0.5))
|
|
.border_1()
|
|
.border_color(cx.theme().colors().border_variant)
|
|
.child(
|
|
div().child(
|
|
Label::new("To improve edit predictions, please consider contributing to our open dataset based on your interactions within open source repositories.")
|
|
.mb_1()
|
|
)
|
|
)
|
|
.child(info_item(
|
|
"We collect data exclusively from open source projects.",
|
|
))
|
|
.child(info_item(
|
|
"Zed automatically detects if your project is open source.",
|
|
))
|
|
.child(info_item("Toggle participation at any time via the status bar menu."))
|
|
.child(multiline_info_item(
|
|
"If turned on, this setting applies for all open source repositories",
|
|
label_item("you open in Zed.")
|
|
))
|
|
.child(multiline_info_item(
|
|
"Files with sensitive data, like `.env`, are excluded by default",
|
|
h_flex()
|
|
.w_full()
|
|
.flex_wrap()
|
|
.child(label_item("via the"))
|
|
.child(
|
|
Button::new("doc-link", "disabled_globs").on_click(
|
|
cx.listener(Self::inline_completions_doc),
|
|
),
|
|
)
|
|
.child(label_item("setting.")),
|
|
))
|
|
}
|
|
}
|
|
|
|
impl Render for ZedPredictModal {
|
|
fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let window_height = window.viewport_size().height;
|
|
let max_height = window_height - px(200.);
|
|
|
|
let has_subscription_period = self.user_store.read(cx).subscription_period().is_some();
|
|
let plan = self.user_store.read(cx).current_plan().filter(|_| {
|
|
// Since the user might be on the legacy free plan we filter based on whether we have a subscription period.
|
|
has_subscription_period
|
|
});
|
|
|
|
let base = v_flex()
|
|
.id("edit-prediction-onboarding")
|
|
.key_context("ZedPredictModal")
|
|
.relative()
|
|
.w(px(550.))
|
|
.h_full()
|
|
.max_h(max_height)
|
|
.p_4()
|
|
.gap_2()
|
|
.when(self.data_collection_expanded, |element| {
|
|
element.overflow_y_scroll()
|
|
})
|
|
.when(!self.data_collection_expanded, |element| {
|
|
element.overflow_hidden()
|
|
})
|
|
.elevation_3(cx)
|
|
.track_focus(&self.focus_handle(cx))
|
|
.on_action(cx.listener(Self::cancel))
|
|
.on_action(cx.listener(|_, _: &menu::Cancel, _window, cx| {
|
|
onboarding_event!("Cancelled", trigger = "Action");
|
|
cx.emit(DismissEvent);
|
|
}))
|
|
.on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, _cx| {
|
|
this.focus_handle.focus(window);
|
|
}))
|
|
.child(
|
|
div()
|
|
.p_1p5()
|
|
.absolute()
|
|
.top_1()
|
|
.left_1()
|
|
.right_0()
|
|
.h(px(200.))
|
|
.child(
|
|
svg()
|
|
.path("icons/zed_predict_bg.svg")
|
|
.text_color(cx.theme().colors().icon_disabled)
|
|
.w(px(530.))
|
|
.h(px(128.))
|
|
.overflow_hidden(),
|
|
),
|
|
)
|
|
.child(
|
|
h_flex()
|
|
.w_full()
|
|
.mb_2()
|
|
.justify_between()
|
|
.child(
|
|
v_flex()
|
|
.gap_1()
|
|
.child(
|
|
Label::new("Introducing Zed AI's")
|
|
.size(LabelSize::Small)
|
|
.color(Color::Muted),
|
|
)
|
|
.child(Headline::new("Edit Prediction").size(HeadlineSize::Large)),
|
|
)
|
|
.child({
|
|
let tab = |n: usize| {
|
|
let text_color = cx.theme().colors().text;
|
|
let border_color = cx.theme().colors().text_accent.opacity(0.4);
|
|
|
|
h_flex().child(
|
|
h_flex()
|
|
.px_4()
|
|
.py_0p5()
|
|
.bg(cx.theme().colors().editor_background)
|
|
.border_1()
|
|
.border_color(border_color)
|
|
.rounded_sm()
|
|
.font(theme::ThemeSettings::get_global(cx).buffer_font.clone())
|
|
.text_size(TextSize::XSmall.rems(cx))
|
|
.text_color(text_color)
|
|
.child("tab")
|
|
.with_animation(
|
|
n,
|
|
Animation::new(Duration::from_secs(2)).repeat(),
|
|
move |tab, delta| {
|
|
let delta = (delta - 0.15 * n as f32) / 0.7;
|
|
let delta = 1.0 - (0.5 - delta).abs() * 2.;
|
|
let delta = ease_in_out(delta.clamp(0., 1.));
|
|
let delta = 0.1 + 0.9 * delta;
|
|
|
|
tab.border_color(border_color.opacity(delta))
|
|
.text_color(text_color.opacity(delta))
|
|
},
|
|
),
|
|
)
|
|
};
|
|
|
|
v_flex()
|
|
.gap_2()
|
|
.items_center()
|
|
.pr_2p5()
|
|
.child(tab(0).ml_neg_20())
|
|
.child(tab(1))
|
|
.child(tab(2).ml_20())
|
|
}),
|
|
)
|
|
.child(h_flex().absolute().top_2().right_2().child(
|
|
IconButton::new("cancel", IconName::X).on_click(cx.listener(
|
|
|_, _: &ClickEvent, _window, cx| {
|
|
onboarding_event!("Cancelled", trigger = "X click");
|
|
cx.emit(DismissEvent);
|
|
},
|
|
)),
|
|
));
|
|
|
|
let blog_post_button = Button::new("view-blog", "Read the Blog Post")
|
|
.full_width()
|
|
.icon(IconName::ArrowUpRight)
|
|
.icon_size(IconSize::Indicator)
|
|
.icon_color(Color::Muted)
|
|
.on_click(cx.listener(Self::view_blog));
|
|
|
|
if self.user_store.read(cx).current_user().is_some() {
|
|
let copy = match self.sign_in_status {
|
|
SignInStatus::Idle => {
|
|
"Zed can now predict your next edit on every keystroke. Powered by Zeta, our open-source, open-dataset language model."
|
|
}
|
|
SignInStatus::SignedIn => "Almost there! Ensure you:",
|
|
SignInStatus::Waiting => unreachable!(),
|
|
};
|
|
|
|
let accordion_icons = if self.data_collection_expanded {
|
|
(IconName::ChevronUp, IconName::ChevronDown)
|
|
} else {
|
|
(IconName::ChevronDown, IconName::ChevronUp)
|
|
};
|
|
|
|
base.child(Label::new(copy).color(Color::Muted))
|
|
.child(h_flex().map(|parent| {
|
|
if let Some(plan) = plan {
|
|
parent.child(
|
|
Checkbox::new("plan", ToggleState::Selected)
|
|
.fill()
|
|
.disabled(true)
|
|
.label(format!(
|
|
"You get {} edit predictions through your {}.",
|
|
if plan == proto::Plan::Free {
|
|
"2,000"
|
|
} else {
|
|
"unlimited"
|
|
},
|
|
match plan {
|
|
proto::Plan::Free => "Zed Free plan",
|
|
proto::Plan::ZedPro => "Zed Pro plan",
|
|
proto::Plan::ZedProTrial => "Zed Pro trial",
|
|
}
|
|
)),
|
|
)
|
|
} else {
|
|
parent
|
|
.child(
|
|
Checkbox::new("plan-required", ToggleState::Unselected)
|
|
.fill()
|
|
.disabled(true)
|
|
.label("To get started with edit prediction"),
|
|
)
|
|
.child(
|
|
Button::new("subscribe", "choose a plan")
|
|
.icon(IconName::ArrowUpRight)
|
|
.icon_size(IconSize::Indicator)
|
|
.icon_color(Color::Muted)
|
|
.on_click(|_event, _window, cx| {
|
|
cx.open_url(&zed_urls::account_url(cx));
|
|
}),
|
|
)
|
|
}
|
|
}))
|
|
.child(
|
|
h_flex()
|
|
.child(
|
|
Checkbox::new("tos-checkbox", self.terms_of_service.into())
|
|
.fill()
|
|
.label("I have read and accept the")
|
|
.on_click(cx.listener(move |this, state, _window, cx| {
|
|
this.terms_of_service = *state == ToggleState::Selected;
|
|
cx.notify();
|
|
})),
|
|
)
|
|
.child(
|
|
Button::new("view-tos", "Terms of Service")
|
|
.icon(IconName::ArrowUpRight)
|
|
.icon_size(IconSize::Indicator)
|
|
.icon_color(Color::Muted)
|
|
.on_click(cx.listener(Self::view_terms)),
|
|
),
|
|
)
|
|
.child(
|
|
v_flex()
|
|
.child(
|
|
h_flex()
|
|
.flex_wrap()
|
|
.child(
|
|
Checkbox::new(
|
|
"training-data-checkbox",
|
|
self.data_collection_opted_in.into(),
|
|
)
|
|
.label(
|
|
"Contribute to the open dataset when editing open source.",
|
|
)
|
|
.fill()
|
|
.on_click(cx.listener(
|
|
move |this, state, _window, cx| {
|
|
this.data_collection_opted_in =
|
|
*state == ToggleState::Selected;
|
|
cx.notify()
|
|
},
|
|
)),
|
|
)
|
|
.child(
|
|
Button::new("learn-more", "Learn More")
|
|
.icon(accordion_icons.0)
|
|
.icon_size(IconSize::Indicator)
|
|
.icon_color(Color::Muted)
|
|
.on_click(cx.listener(|this, _, _, cx| {
|
|
this.data_collection_expanded =
|
|
!this.data_collection_expanded;
|
|
cx.notify();
|
|
|
|
if this.data_collection_expanded {
|
|
onboarding_event!(
|
|
"Data Collection Learn More Clicked"
|
|
);
|
|
}
|
|
})),
|
|
),
|
|
)
|
|
.when(self.data_collection_expanded, |element| {
|
|
element.child(self.render_data_collection_explanation(cx))
|
|
}),
|
|
)
|
|
.child(
|
|
v_flex()
|
|
.mt_2()
|
|
.gap_2()
|
|
.w_full()
|
|
.child(
|
|
Button::new("accept-tos", "Enable Edit Prediction")
|
|
.disabled(plan.is_none() || !self.terms_of_service)
|
|
.style(ButtonStyle::Tinted(TintColor::Accent))
|
|
.full_width()
|
|
.on_click(cx.listener(Self::accept_and_enable)),
|
|
)
|
|
.child(blog_post_button),
|
|
)
|
|
} else {
|
|
base.child(
|
|
Label::new("To set Zed as your edit prediction provider, please sign in.")
|
|
.color(Color::Muted),
|
|
)
|
|
.child(
|
|
v_flex()
|
|
.mt_2()
|
|
.gap_2()
|
|
.w_full()
|
|
.child(
|
|
Button::new("accept-tos", "Sign in with GitHub")
|
|
.disabled(self.sign_in_status == SignInStatus::Waiting)
|
|
.style(ButtonStyle::Tinted(TintColor::Accent))
|
|
.full_width()
|
|
.on_click(cx.listener(Self::sign_in)),
|
|
)
|
|
.child(blog_post_button),
|
|
)
|
|
}
|
|
}
|
|
}
|