true
null
nil
-
false
Nighty
...any)?
local ok, found = pcall(function()
return object[newName]
end)
if ok and type(found) == "function" then
return found
end
local okOld, old = pcall(function()
return object[oldName]
end)
if okOld and type(old) == "function" then
return old
end
return nil
end
local toolbar = plugin:CreateToolbar(Brand.pluginName)
local button = toolbar:CreateButton(
WIDGET_ID .. "_Open",
"Import " .. Brand.productName .. " designs, update them in place, send UI back",
ICON,
Brand.pluginName
)
button.ClickableWhenViewportHidden = true
local info = DockWidgetPluginGuiInfo.new(Enum.InitialDockState.Right, false, false, 320, 600, 240, 320)
local createWidget = method(plugin, "CreateDockWidgetPluginGuiAsync", "CreateDockWidgetPluginGui")
assert(createWidget, "This Studio can't make plugin windows.")
local widget: DockWidgetPluginGui = createWidget(plugin, WINDOW_ID, info)
widget.Title = Brand.pluginName
widget.Name = WIDGET_ID
widget.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
local function pickFile(): (buffer?, string?)
local prompt = method(StudioService, "PromptImportFileAsync", "PromptImportFile")
if prompt == nil then
error("This Studio can't open files from a plugin.")
end
local file = prompt(StudioService, EXTENSIONS)
if file == nil then
return nil, nil
end
local contents = file:GetBinaryContents()
return buffer.fromstring(contents), file.Name
end
local function saveSelection(fileName: string): boolean
local save = method(plugin, "PromptSaveSelectionAsync", "PromptSaveSelection")
if save == nil then
error("This Studio can't save files from a plugin.")
end
return save(plugin, fileName) == true
end
local app = App.new({
host = widget,
settings = Settings.new(Settings.pluginStorage(plugin)),
uploader = Uploader.new(),
recorder = History.studio,
pickFile = pickFile,
getSelection = function()
return Selection:Get()
end,
setSelection = function(instances: { Instance })
Selection:Set(instances)
end,
saveSelection = saveSelection,
service = function(name: string): Instance
return game:GetService(name)
end,
isRunning = function()
return RunService:IsRunning()
end,
userId = Uploader.userId,
userName = function(userId: number): string?
return Players:GetNameFromUserIdAsync(userId)
end,
clock = os.clock,
wait = function(seconds: number)
task.wait(seconds)
end,
log = function(text: string)
print(text)
end,
random = Random.new(),
fetch = function(url: string): string
return HttpService:GetAsync(url, true)
end,
now = os.time,
})
task.spawn(function()
app:loadUserName()
end)
local stopCopies = function() end
pcall(function()
stopCopies = Copies.watch(
game:GetService("PluginGuiService"),
widget,
Brand.pluginVersion,
Brand.pluginRelease,
function(others: { string })
app:setCopies(others)
end
)
end)
button.Click:Connect(function()
widget.Enabled = not widget.Enabled
if widget.Enabled then
app.ui:focusPaste()
end
end)
local function syncButton()
button:SetActive(widget.Enabled)
end
widget:GetPropertyChangedSignal("Enabled"):Connect(syncButton)
syncButton()
local function lookForUpdates()
if widget.Enabled then
task.spawn(function()
app:checkForUpdates()
end)
end
end
widget:GetPropertyChangedSignal("Enabled"):Connect(lookForUpdates)
lookForUpdates()
local pasteAction = plugin:CreatePluginAction(
WIDGET_ID .. "_Paste",
"Paste a design (" .. Brand.pluginName .. ")",
"Open " .. Brand.pluginName .. ", ready to paste the code copied in " .. Brand.productName,
ICON,
true
)
pasteAction.Triggered:Connect(function()
widget.Enabled = true
app.ui:focusPaste()
end)
local fileAction = plugin:CreatePluginAction(
WIDGET_ID .. "_ImportFile",
"Import a design file (" .. Brand.pluginName .. ")",
"Pick a ." .. Brand.bundleExtension .. " file from " .. Brand.productName .. " and import it",
ICON,
true
)
fileAction.Triggered:Connect(function()
widget.Enabled = true
app:importFile()
end)
plugin.Unloading:Connect(function()
stopCopies()
app:destroy()
end)
]]>
-
App
(buffer?, string?),
getSelection: () -> { Instance },
setSelection: ({ Instance }) -> (),
saveSelection: (fileName: string) -> boolean,
service: (name: string) -> Instance,
isRunning: () -> boolean,
userId: () -> number,
userName: (userId: number) -> string?,
clock: () -> number,
wait: (seconds: number) -> (),
log: (text: string) -> (),
random: Random,
fetch: ((url: string) -> string)?,
now: (() -> number)?,
}
type Pending = {
bundle: Bundle.Bundle,
plan: Builder.Plan,
selection: { Instance },
fallback: Instance,
needs: Images.Needs,
fileName: string,
resolution: Images.Resolution?,
}
export type App = typeof(setmetatable(
{} :: {
deps: Deps,
ui: Ui.Ui,
busy: boolean,
phase: string,
pending: Pending?,
collector: Paste.Collector,
cancelRequested: boolean,
userName: string?,
newestPlugin: string?,
newestRelease: number?,
newestUrl: string?,
otherCopies: { string },
hidden: { [string]: boolean },
updateOpen: boolean,
checking: boolean,
destroyed: boolean,
},
App
))
local NOTES_SHOWN = 3
local function plural(count: number, one: string, many: string?): string
return string.format("%d %s", count, if count == 1 then one else many or one .. "s")
end
local function changes(added: number, updated: number, unchanged: number, removed: number, past: boolean): string
local parts = {}
if added > 0 then
table.insert(parts, string.format(if past then "added %d" else "%d new", added))
end
if updated > 0 then
table.insert(parts, string.format(if past then "updated %d" else "%d changed", updated))
end
if removed > 0 then
table.insert(parts, string.format(if past then "removed %d" else "%d to remove", removed))
end
if #parts == 0 then
return if past then "Nothing needed to change." else "Nothing changed since the last import."
end
local line = table.concat(parts, ", ")
line = string.upper(string.sub(line, 1, 1)) .. string.sub(line, 2)
if unchanged > 0 then
line ..= string.format(" (%d unchanged)", unchanged)
end
return line .. "."
end
local function placeName(instance: Instance?): string
if instance == nil then
return "nowhere"
end
if instance.Parent == game then
return instance.Name
end
return instance:GetFullName()
end
local function ago(at: number): string
local seconds = os.time() - at
if seconds < 60 then
return "just now"
elseif seconds < 3600 then
return plural(seconds // 60, "minute") .. " ago"
elseif seconds < 86400 then
return plural(seconds // 3600, "hour") .. " ago"
end
return os.date("%d %b %Y", at)
end
local function firstNotes(notes: { string }, extra: { string }?): { string }
local out = {}
for index, note in notes do
if index > NOTES_SHOWN then
table.insert(out, string.format("…and %d more (all listed in the Output window).", #notes - NOTES_SHOWN))
break
end
table.insert(out, note)
end
if extra then
for _, note in extra do
table.insert(out, note)
end
end
return out
end
function App.new(deps: Deps): App
local self: App
local handlers: Ui.Handlers = {
paste = function(text: string)
self:paste(text)
end,
importFile = function()
self:importFile()
end,
export = function()
self:export()
end,
confirm = function()
self:confirm()
end,
cancel = function()
self:cancel()
end,
placeholders = function()
self:continueWithoutUploads()
end,
dismiss = function()
self:home()
end,
setTarget = function(value: string)
self.deps.settings:setTarget(value)
self:refreshSettings()
end,
setCreator = function(kind: string, groupId: number?)
self.deps.settings:setCreator(kind, groupId)
self:refreshSettings()
local pending = self.pending
if self.phase == "blocked" and not self.busy and pending and pending.resolution == nil and self:creator() then
self:showSummary()
end
end,
forgetUploads = function()
self.deps.settings:forgetUploads()
self:refreshSettings()
end,
hideNotice = function(id: string)
self.hidden[id] = true
self:refreshNotices()
end,
noticeAction = function(_id: string, action: string)
self:updateAction(action)
end,
setUpdateCheck = function(on: boolean)
self:setUpdateCheck(on)
end,
}
deps.settings:migrate()
self = setmetatable({
deps = deps,
ui = Ui.new(deps.host, handlers, {
pluginName = Brand.pluginName,
toolName = Brand.productName,
guideUrl = Brand.guideUrl,
version = Brand.pluginVersion,
copyright = Brand.copyright,
}),
busy = false,
phase = "idle",
pending = nil :: Pending?,
collector = Paste.collector(),
cancelRequested = false,
userName = nil :: string?,
newestPlugin = nil :: string?,
newestRelease = nil :: number?,
newestUrl = nil :: string?,
otherCopies = {} :: { string },
hidden = {} :: { [string]: boolean },
updateOpen = false,
checking = false,
destroyed = false,
}, App)
self:refreshSettings()
self:home()
self:refreshNotices()
return self
end
function App.log(self: App, text: string)
self.deps.log("[" .. Brand.pluginName .. "] " .. text)
end
function App.targetLabel(self: App, value: string): string
if value == "file" then
return "Where the file says (usually StarterGui)"
end
return value
end
function App.refreshSettings(self: App)
local settings = self.deps.settings
local choices = {}
for _, value in Settings.TARGETS do
table.insert(choices, { value = value, label = self:targetLabel(value) })
end
local creator = settings:creator()
self.ui:setSettings({
target = settings:target(),
targetChoices = choices,
creatorKind = creator.kind,
groupId = creator.groupId,
userName = self.userName,
uploaded = settings:uploadedCount(),
updateCheck = not settings:updates().off,
})
end
function App.updateText(self: App, release: Updates.Release?): string
return string.format(
"%s %s is out (you have %s). Download it from %s and replace %s in your Plugins folder — your settings stay.",
Brand.pluginName,
if release then release.version else self.newestPlugin or "",
Brand.pluginVersion,
if release then release.url else self.newestUrl or Brand.guideUrl,
Brand.pluginFileName
)
end
function App.updateSteps(): { string }
return {
"Copy the guide's address into your browser and download " .. Brand.pluginFileName .. ":",
"Put it in your Plugins folder (Plugins tab → Plugins Folder) in place of the old " .. Brand.pluginFileName .. ".",
"Restart Studio. Your settings and uploads stay.",
}
end
function App.newerRelease(self: App): Updates.Release?
local pasted: Updates.Release? = nil
if self.newestPlugin and self.newestRelease then
pasted = { version = self.newestPlugin, release = self.newestRelease, url = self.newestUrl or Brand.guideUrl }
end
return Updates.shown(self.deps.settings:updates(), pasted, Brand.pluginRelease)
end
function App.updateNotice(self: App, release: Updates.Release): Ui.Notice
local open = self.updateOpen
local actions: { Ui.Action } = {
{ id = "UpdateHow", label = if open then "Hide steps" else "How to update" },
{ id = "UpdateLater", label = "Later" },
}
if self.deps.fetch and not self.deps.settings:updates().off then
table.insert(actions, { id = "UpdateOff", label = "Don't check" })
end
return {
id = "update " .. release.version,
title = string.format("%s %s is out", Brand.pluginName, release.version),
text = release.notes or string.format("You have %s. Updating keeps your settings.", Brand.pluginVersion),
steps = if open then App.updateSteps() else nil,
link = if open then release.url else nil,
actions = actions,
tone = "info",
}
end
function App.updateAction(self: App, action: string)
if action == "UpdateHow" then
self.updateOpen = not self.updateOpen
self:refreshNotices()
return
end
if action ~= "UpdateLater" and action ~= "UpdateOff" then
return
end
local release = self:newerRelease()
local state = table.clone(self.deps.settings:updates())
if release then
state.later = math.max(state.later or 0, release.release)
end
if action == "UpdateOff" then
state.off = true
end
self.deps.settings:setUpdates(state)
self.updateOpen = false
self:refreshSettings()
self:refreshNotices()
end
function App.setUpdateCheck(self: App, on: boolean)
local state = table.clone(self.deps.settings:updates())
if state.off == not on then
return
end
state.off = not on
self.deps.settings:setUpdates(state)
self:refreshSettings()
self:refreshNotices()
if on then
self:checkForUpdates()
end
end
function App.checkForUpdates(self: App)
local fetch = self.deps.fetch
if fetch == nil or self.checking or self.destroyed then
return
end
self.checking = true
local now = if self.deps.now then self.deps.now() else os.time()
local ok, found = pcall(Updates.check, self.deps.settings, fetch, now)
self.checking = false
if self.destroyed then
return
end
local shown = self:newerRelease()
if ok and found and shown and shown.release == found.release then
self:log(self:updateText(shown))
end
self:refreshNotices()
end
local function copiesText(others: { string }): (string, string)
local count = #others + 1
local title = Brand.pluginName .. " is installed " .. (if count == 2 then "twice" else count .. " times")
local same = true
local names = {}
for _, version in others do
same = same and version == Brand.pluginVersion
table.insert(names, if version == "" then "an older version" else "v" .. version)
end
local files = if count == 2 then "file" else "files"
local folder = "your Plugins folder (Plugins tab → Plugins Folder), then restart Studio. Your settings stay."
if same then
return title, string.format("All copies are v%s. Keep one: remove the other %s from %s", Brand.pluginVersion, files, folder)
end
return title,
string.format(
"This one is v%s; the other %s %s. Keep the newest: remove the other %s from %s",
Brand.pluginVersion,
if count == 2 then "is" else "ones are",
table.concat(names, " and "),
files,
folder
)
end
function App.refreshNotices(self: App)
if self.destroyed then
return
end
local notices: { Ui.Notice } = {}
if #self.otherCopies > 0 and not self.hidden.copies then
local title, text = copiesText(self.otherCopies)
table.insert(notices, { id = "copies", title = title, text = text, tone = "warn" })
end
local release = self:newerRelease()
if release and not self.hidden["update " .. release.version] then
table.insert(notices, self:updateNotice(release))
end
self.ui:setNotices(notices)
end
function App.noteNewestPlugin(self: App, bundle: Bundle.Bundle)
local version, release = bundle.pluginVersion, bundle.pluginRelease
if version == nil or release == nil or release <= Brand.pluginRelease then
return
end
local known = self.newestRelease
if known and release <= known then
return
end
self.newestPlugin = version
self.newestRelease = release
self.newestUrl = bundle.pluginUrl or Brand.guideUrl
self:log(self:updateText(nil))
self:refreshNotices()
end
function App.setCopies(self: App, others: { string })
self.otherCopies = others
if #others > 0 then
local title, text = copiesText(others)
self:log(title .. ". " .. text)
end
self:refreshNotices()
end
function App.loadUserName(self: App)
local id = self.deps.userId()
if id <= 0 then
return
end
local ok, name = pcall(self.deps.userName, id)
if ok and type(name) == "string" and not self.destroyed then
self.userName = name
self:refreshSettings()
end
end
function App.home(self: App)
if self.busy then
return
end
self.phase = "idle"
self.pending = nil
local settings = self.deps.settings
local target = settings:target()
local goes = if target == "file" then "StarterGui (or where the file says)" else target
local notes = { "New designs go to " .. goes .. ". To update an earlier import, select it before importing." }
local last = settings:lastImport()
if last then
local lines = { changes(last.added, last.updated, 0, last.removed, true) }
if last.uploaded > 0 then
table.insert(lines, "Uploaded " .. plural(last.uploaded, "image") .. ".")
end
if last.empty > 0 then
table.insert(lines, plural(last.empty, "image") .. " left empty. Import again to upload them.")
end
self.ui:show({
view = "home",
title = "Last import",
text = '"' .. last.project .. '", ' .. ago(last.at) .. ".",
lines = lines,
notes = notes,
})
else
self.ui:show({ view = "home", title = "", notes = notes })
end
end
function App.showError(self: App, title: string, err: any, extra: string?)
self:log(title .. ": " .. Errors.detail(err))
self.busy = false
self.phase = "idle"
self.pending = nil
local update = Errors.kind(err) == "update"
self.ui:show({
view = "error",
title = if update then "Update " .. Brand.pluginName else title,
text = Errors.message(err) .. (if extra then " " .. extra else ""),
link = if update then Brand.guideUrl else nil,
tone = if update then "warn" else "error",
actions = { { id = "dismiss", label = "OK" } },
})
end
function App.working(self: App, title: string, text: string?, progress: number?, cancellable: boolean?)
self.ui:show({
view = "working",
title = title,
text = text,
progress = progress,
busy = true,
actions = if cancellable then { { id = "cancel", label = "Cancel", primary = false } } else nil,
})
end
function App.fallback(self: App, bundle: Bundle.Bundle): Instance
local target = self.deps.settings:target()
return self.deps.service(if target == "file" then bundle.target else target)
end
function App.creator(self: App): Images.Creator?
local creator = self.deps.settings:creator()
if creator.kind == "group" then
if creator.groupId then
return { kind = "group", id = creator.groupId }
end
return nil
end
return { kind = "user", id = self.deps.userId() }
end
function App.paste(self: App, text: string)
if self.busy then
return
end
local found, parts = xpcall(Paste.find, Errors.handler, text)
if not found then
self:showError("Couldn't read the code", parts)
return
end
local state = Paste.add(self.collector, parts)
if not state.complete then
self.phase = "pasting"
self.pending = nil
local notes = { "The parts can be pasted in any order." }
if state.restarted then
table.insert(notes, 1, "That part belongs to another export, so the parts pasted before it were set aside.")
end
local segments = {}
for number = 1, state.need do
segments[number] = table.find(state.missing, number) == nil
end
self.ui:show({
view = "pasting",
title = "Paste the next part",
text = Paste.describe(state) .. " Copy the next part in " .. Brand.productName .. ", then paste it in the box above.",
progress = state.have / state.need,
segments = segments,
notes = notes,
tone = "info",
actions = { { id = "cancel", label = "Start over", primary = false } },
})
return
end
local collector = self.collector
self.collector = Paste.collector()
self:startImport("the pasted code", function(): (buffer?, string?)
return Paste.assemble(collector), "the pasted code"
end)
end
function App.importFile(self: App)
self:startImport("Choose a design file", function(): (buffer?, string?)
return self.deps.pickFile()
end)
end
function App.startImport(self: App, title: string, getBytes: () -> (buffer?, string?))
if self.busy then
return
end
if self.deps.isRunning() then
self:showError("Can't import now", Errors.new("Stop the playtest first: changes made while testing are lost when it stops."))
return
end
self.busy = true
self.phase = "picking"
self.pending = nil
if title == "Choose a design file" then
self:working(title, "Pick the ." .. Brand.bundleExtension .. " file you exported from " .. Brand.productName .. ".")
else
self:working("Reading " .. title, nil)
self.deps.wait(0)
end
local read = function()
local bytes, fileName = getBytes()
if bytes == nil then
return
end
local name = fileName or "the file"
self:working("Reading " .. name, nil)
self.deps.wait(0)
local bundle = Bundle.parse(bytes)
self:noteNewestPlugin(bundle)
for _, warning in bundle.warnings do
self:log(warning)
end
local selection = self.deps.getSelection()
local fallback = self:fallback(bundle)
local plan = Builder.plan(bundle, { selection = selection, fallback = fallback })
local needs = Images.needs(bundle, self.deps.settings:imageCache())
self.pending = {
bundle = bundle,
plan = plan,
selection = selection,
fallback = fallback,
needs = needs,
fileName = name,
resolution = nil,
}
end
local ok, err = xpcall(read :: any, Errors.handler)
self.busy = false
if not ok then
self:showError(if title == "Choose a design file" then "Couldn't read the file" else "Couldn't read the code", err)
return
end
if self.pending == nil then
self:home()
return
end
self:showSummary()
end
function App.showSummary(self: App)
local pending = self.pending
if pending == nil then
return
end
self.phase = "summary"
local bundle, plan, needs = pending.bundle, pending.plan, pending.needs
local lines = {}
local rootKeys: { [string]: boolean } = {}
for _, target in plan.targets do
rootKeys[target.root.key] = true
end
for _, target in plan.targets do
local owner = string.match(target.root.key, "^(.-):")
if owner and rootKeys[owner] then
continue
end
local existing = target.existing
local holder = plan.holder
if existing then
table.insert(lines, 'Updates "' .. existing.Name .. '" in ' .. placeName(existing.Parent))
else
if target.inHolder and holder then
table.insert(lines, 'Adds "' .. target.root.name .. '" to a new ScreenGui "' .. holder.name .. '" in ' .. placeName(target.parent))
else
table.insert(lines, 'Adds "' .. target.root.name .. '" to ' .. placeName(target.parent))
end
local ignored = target.ignored
if ignored then
table.insert(
lines,
string.format("(The selected %s %q can't hold a %s.)", ignored.ClassName, ignored.Name, target.root.className)
)
end
end
end
table.insert(lines, changes(plan.added, plan.updated, plan.unchanged, plan.removed, false))
local known = 0
for _ in needs.known do
known += 1
end
local extra = {}
if #needs.upload > 0 then
local line = plural(#needs.upload, "image") .. " to upload"
if known > 0 then
line ..= ", " .. known .. " already on Roblox"
end
table.insert(lines, line .. ".")
local creator = self.deps.settings:creator()
table.insert(
extra,
if creator.kind == "group"
then "Images are uploaded to group " .. (if creator.groupId then tostring(creator.groupId) else "(no id yet: set it in Settings)") .. "."
else "Images are uploaded to your account" .. (if self.userName then " (" .. self.userName .. ")" else "") .. "."
)
elseif known > 0 then
table.insert(lines, plural(known, "image") .. ", all already on Roblox.")
end
if #needs.missing > 0 then
table.insert(lines, plural(#needs.missing, "image") .. " missing from the file (left empty).")
end
self.ui:show({
view = "summary",
title = "Ready to import",
text = 'Design: "' .. bundle.projectName .. '"',
lines = lines,
warnings = firstNotes(bundle.warnings),
notes = extra,
tone = "info",
actions = { { id = "confirm", label = "Import", primary = true }, { id = "cancel", label = "Cancel", primary = false } },
})
end
function App.confirm(self: App)
local pending = self.pending
if self.busy or pending == nil or self.phase ~= "summary" then
return
end
if self.deps.isRunning() then
self:showError("Can't import now", Errors.new("Stop the playtest first: changes made while testing are lost when it stops."))
return
end
local creator = self:creator()
if #pending.needs.upload > 0 and creator == nil then
self.phase = "blocked"
self.ui:show({
view = "blocked",
title = "Which group gets the images?",
text = 'Images go to a group, but its id is missing. Open Settings and type the group id, or pick "Me".',
tone = "warn",
actions = {
{ id = "settings", label = "Open Settings", primary = true },
{ id = "placeholders", label = "Import with empty images", primary = false },
{ id = "cancel", label = "Cancel", primary = false },
},
})
return
end
self.busy = true
self.phase = "uploading"
self.cancelRequested = false
local total = #pending.needs.upload
if total > 0 then
self:working("Uploading images", "Getting ready…", 0, true)
end
local uploadNote = "If Studio asks whether " .. Brand.pluginName .. " may upload, choose Allow: it uploads only this design's images, so they show in your game."
local ok, resolution = xpcall(Images.resolve, Errors.handler, pending.bundle, {
uploader = self.deps.uploader,
cache = self.deps.settings:imageCache(),
creator = creator or { kind = "user", id = 0 },
description = string.format('Uploaded by the %s plugin for the design "%s".', Brand.pluginName, pending.bundle.projectName),
allowUpload = true,
isCancelled = function()
return self.cancelRequested or self.destroyed
end,
progress = function(done: number, count: number, text: string)
if not self.cancelRequested then
self.ui:show({
view = "working",
title = "Uploading images",
text = text,
progress = if count > 0 then done / count else nil,
notes = { uploadNote },
busy = true,
actions = { { id = "cancel", label = "Cancel", primary = false } },
})
end
end,
clock = self.deps.clock,
wait = self.deps.wait,
})
self.busy = false
if not ok then
self:showError("Couldn't upload the images", resolution)
return
end
pending.resolution = resolution
for _, message in resolution.errors do
self:log(message)
end
if resolution.cancelled then
self.phase = "idle"
self.pending = nil
self.ui:show({
view = "done",
title = "Import cancelled",
text = "Nothing was changed in your place.",
lines = if resolution.uploaded > 0
then { plural(resolution.uploaded, "image") .. " uploaded so far; the next import won't upload them again." }
else nil,
tone = "info",
actions = { { id = "dismiss", label = "OK" } },
})
self:refreshSettings()
return
end
local blocked = resolution.blocked
if blocked then
self:log("Uploads are not allowed: " .. blocked.message)
self.phase = "blocked"
self.ui:show({
view = "blocked",
title = "Images can't be uploaded",
text = blocked.message,
steps = Uploader.HELP,
notes = if resolution.uploaded > 0
then { plural(resolution.uploaded, "image") .. " uploaded before this are remembered." }
else { "You can import now with empty images, and import again once uploads work." },
tone = "warn",
actions = {
{ id = "placeholders", label = "Import with empty images", primary = true },
{ id = "cancel", label = "Cancel", primary = false },
},
})
self:refreshSettings()
return
end
self:build()
end
function App.continueWithoutUploads(self: App)
local pending = self.pending
if self.busy or pending == nil or self.phase ~= "blocked" then
return
end
if pending.resolution == nil then
local ok, resolution = xpcall(Images.resolve, Errors.handler, pending.bundle, {
uploader = self.deps.uploader,
cache = self.deps.settings:imageCache(),
creator = { kind = "user", id = 0 },
description = "",
allowUpload = false,
isCancelled = function()
return false
end,
progress = function() end,
clock = self.deps.clock,
wait = self.deps.wait,
})
if not ok then
self:showError("Couldn't import", resolution)
return
end
pending.resolution = resolution
end
self:build()
end
function App.build(self: App)
local pending = self.pending
local resolution = pending and pending.resolution
if pending == nil or resolution == nil then
return
end
if self.deps.isRunning() then
self:showError("Can't import now", Errors.new("Stop the playtest first: changes made while testing are lost when it stops."))
return
end
self.busy = true
self.phase = "building"
self:working("Building", "Putting the design in place…")
self.deps.wait(0)
local bundle = pending.bundle
local selection = {}
for _, instance in pending.selection do
if instance:IsDescendantOf(game) then
table.insert(selection, instance)
end
end
local result: Builder.Result? = nil
local ok, err = xpcall(function()
local plan = Builder.plan(bundle, { selection = selection, fallback = pending.fallback })
local recorded, failure = History.run(self.deps.recorder, "NKD_Import", Brand.pluginName .. ": import " .. bundle.projectName, function()
local built = Builder.apply(bundle, plan, resolution.contents)
result = built
if #built.scrolls > 0 then
self.deps.wait(0)
Builder.settleScrolls(built)
end
end)
if not recorded then
error(failure, 0)
end
end, Errors.handler)
self.busy = false
self.pending = nil
local built = result
if not ok or built == nil then
self:showError("Couldn't import", err, "Nothing in your place was changed.")
return
end
self.deps.setSelection(built.roots)
for _, problem in built.problems do
self:log(problem)
end
local empty = resolution.missing
self.deps.settings:setLastImport({
project = bundle.projectName,
at = os.time(),
added = built.added,
updated = built.updated,
removed = built.removed,
uploaded = resolution.uploaded,
empty = empty,
})
local lines = { changes(built.added, built.updated, built.unchanged, built.removed, true) }
if resolution.uploaded > 0 then
table.insert(lines, "Uploaded " .. plural(resolution.uploaded, "image") .. ". New images can take a minute to show while Roblox checks them.")
end
if empty > 0 then
table.insert(lines, plural(empty, "image") .. " left empty. Import again to upload " .. (if empty == 1 then "it" else "them") .. ".")
end
if built.moved > 0 then
table.insert(lines, "Moved " .. plural(built.moved, "of your objects", "of your objects") .. " out of layers that were removed or replaced, so nothing of yours was lost.")
end
local notes = {}
for _, message in resolution.errors do
table.insert(notes, message)
end
for _, problem in built.problems do
table.insert(notes, problem)
end
self.phase = "idle"
self.ui:show({
view = "done",
title = "Imported",
lines = lines,
warnings = firstNotes(notes),
undo = true,
tone = if empty > 0 or #notes > 0 then "warn" else "ok",
actions = { { id = "dismiss", label = "Done" } },
})
self:log(string.format("Imported \"%s\": %s", bundle.projectName, lines[1]))
self:refreshSettings()
end
function App.cancel(self: App)
if self.phase == "pasting" then
self.collector = Paste.collector()
end
if self.phase == "uploading" then
self.cancelRequested = true
self:working("Uploading images", "Stopping after the current image…", nil, false)
return
end
if self.busy then
return
end
self:home()
end
function App.export(self: App)
if self.busy then
return
end
local selection = self.deps.getSelection()
local nothing = false
local ok, err = xpcall((function()
local hasUi = false
for _, instance in selection do
if Export.isUi(instance) or instance:FindFirstChildWhichIsA("GuiBase2d", true) then
hasUi = true
break
end
end
if not hasUi then
nothing = true
return
end
self.busy = true
self.phase = "exporting"
self:working(
"Save for " .. Brand.productName,
'In the save window, pick "Roblox XML Model Files (*.rbxmx)" as the file type, then save.'
)
local uploads = self.deps.settings:imageCache()
local stamp = Export.stamp()
local prepared: Export.Prepared? = Export.prepare(selection, self.deps.random, true, uploads, stamp)
if prepared and prepared.assigned + prepared.cleared + prepared.stamped > 0 then
local recorded, failure = History.run(self.deps.recorder, "NKD_Export", Brand.pluginName .. ": prepare UI for " .. Brand.productName, function()
prepared = Export.prepare(selection, self.deps.random, false, uploads, stamp)
end)
if not recorded then
error(failure, 0)
end
end
if prepared == nil then
error("no export", 0)
end
local ready = prepared :: Export.Prepared
self.deps.setSelection(ready.roots)
local saved = self.deps.saveSelection(Export.fileName(ready.roots))
self.busy = false
self.phase = "idle"
if saved then
self.ui:show({
view = "done",
title = "Saved for " .. Brand.productName,
text = "In " .. Brand.productName .. ", click Import and pick the file you just saved.",
lines = { plural(ready.count, "UI object") .. " in the file." },
notes = if ready.assigned > 0
then { "Gave " .. plural(ready.assigned, "object") .. " an id, so later imports update the same objects (Ctrl+Z removes the ids)." }
else nil,
tone = "ok",
actions = { { id = "dismiss", label = "Done" } },
})
else
self.ui:show({
view = "done",
title = "Not saved",
text = "The save window was closed. Click Export to designer to try again.",
tone = "info",
actions = { { id = "dismiss", label = "OK" } },
})
end
end) :: any, Errors.handler)
if not ok then
self.busy = false
self:showError("Couldn't export", err)
elseif nothing then
self.ui:show({
view = "error",
title = "Select some UI first",
text = "Select the UI to send to " .. Brand.productName .. " first: a ScreenGui, a Frame, or anything with UI inside. Then click Export to designer.",
tone = "info",
actions = { { id = "dismiss", label = "OK" } },
})
end
end
function App.destroy(self: App)
self.destroyed = true
self.cancelRequested = true
self.ui:destroy()
end
return App
]]>
-
Attributes
-
Brand
-
Builder
())?)
for _, item in result.scrolls do
local instance = item.instance
if instance.Parent ~= nil and instance:IsDescendantOf(game) then
if set then
set(instance, item.position)
else
pcall(assign :: any, instance, "CanvasPosition", item.position)
end
end
end
end
return Builder
]]>
-
Bundle
0 and #value <= 120 and string.match(value, "^[%w_%-:%.#]+$") ~= nil
end
local function isHolder(raw: any): boolean
if type(raw) ~= "table" or raw.className ~= "ScreenGui" or raw.uid ~= nil or type(raw.attributes) ~= "table" then
return false
end
local flag = Attributes.find(raw.attributes, "holder")
return type(flag) == "table" and flag[1] == "bool" and flag[2] == true and Attributes.find(raw.attributes, "id") == nil
end
local function text(value: any, fallback: string, max: number): string
if type(value) ~= "string" or value == "" then
return fallback
end
return string.sub(value, 1, max)
end
function Bundle.parse(data: buffer): Bundle
local archive = Zip.open(data)
local entry = Zip.find(archive, "bundle.json")
if entry == nil then
for _, candidate in archive.entries do
if string.match(candidate.name, "^[^/]+/bundle%.json$") then
entry = candidate
break
end
end
end
if entry == nil then
Errors.fail(NOT_BUNDLE, "bundle: no bundle.json")
end
local found = entry :: Zip.Entry
local prefix = string.sub(found.name, 1, #found.name - #"bundle.json")
if found.size > MAX_BUNDLE_JSON then
Errors.fail("This design is too big for the plugin to read.", "bundle: bundle.json is " .. found.size .. " bytes")
end
local json = buffer.tostring(Zip.read(archive, found))
local ok, raw = pcall(HttpService.JSONDecode, HttpService, json)
if not ok or type(raw) ~= "table" then
Errors.fail(DAMAGED, "bundle: bundle.json is not JSON: " .. tostring(raw))
end
return Bundle.fromTable(raw, archive, prefix)
end
function Bundle.fromTable(raw: any, archive: Zip.Archive, prefix: string?): Bundle
local folder = prefix or ""
if type(raw) ~= "table" or raw.format ~= Bundle.FORMAT then
Errors.fail(NOT_BUNDLE, "bundle: format " .. tostring(if type(raw) == "table" then raw.format else raw))
end
local version = raw.version
if type(version) ~= "number" or version ~= version or version < 1 then
Errors.fail(DAMAGED, "bundle: version " .. tostring(version))
end
if math.floor(version) > Bundle.VERSION then
Errors.fail(
string.format(
"This design was made by a newer version of %s. Update %s: download it again from %s's export window, then import again.",
Brand.productName,
Brand.pluginName,
Brand.productName
),
"bundle: version " .. tostring(version),
"update"
)
end
local project = if type(raw.project) == "table" then raw.project else {}
if not isKey(project.id) then
Errors.fail(DAMAGED, "bundle: project id " .. tostring(project.id))
end
local bundle: Bundle = {
version = version,
projectId = project.id,
projectName = text(project.name, "Design", 200),
target = "StarterGui",
roots = {},
holder = nil,
images = {},
imageOrder = {},
count = 0,
warnings = {},
archive = archive,
}
local target = type(raw.target) == "table" and raw.target.service
if type(target) == "string" and SERVICES[target] then
bundle.target = target
end
local plugin = if type(raw.plugin) == "table" then raw.plugin else {}
if Version.parse(plugin.version) then
bundle.pluginVersion = plugin.version
end
bundle.pluginRelease = Version.release(plugin.release)
local url = plugin.url
if type(url) == "string" and #url <= 300 and string.sub(url, 1, #Brand.siteOrigin + 1) == Brand.siteOrigin .. "/" and not string.find(url, "[%s%c]") then
bundle.pluginUrl = url
end
if raw.images ~= nil and type(raw.images) ~= "table" then
Errors.fail(DAMAGED, "bundle: images is not an object")
end
for hash, info in raw.images or {} do
if type(hash) ~= "string" or #hash ~= 64 or not string.match(hash, "^%x+$") or type(info) ~= "table" then
table.insert(bundle.warnings, "An image entry is broken and was left out.")
continue
end
local key = string.lower(hash)
local file = if type(info.file) == "string" then info.file else "images/" .. key .. ".png"
local zipEntry = Zip.find(archive, folder .. file) or Zip.find(archive, file)
local robloxId = info.robloxId
if type(robloxId) ~= "number" or robloxId ~= math.floor(robloxId) or robloxId <= 0 or robloxId > 2 ^ 53 then
robloxId = nil
end
bundle.images[key] = {
hash = key,
file = if zipEntry then zipEntry.name else file,
name = text(info.name, "Image", 100),
width = if type(info.width) == "number" then info.width else 0,
height = if type(info.height) == "number" then info.height else 0,
robloxId = robloxId,
present = zipEntry ~= nil,
}
end
if type(raw.roots) ~= "table" or #raw.roots == 0 then
Errors.fail("This design file has nothing to import.", "bundle: no roots")
end
local seenKeys: { [string]: boolean } = {}
local imageSeen: { [string]: boolean } = {}
local function note(message: string)
table.insert(bundle.warnings, message)
end
local function uniqueKey(key: string): string
if not seenKeys[key] then
seenKeys[key] = true
return key
end
local number = 2
while seenKeys[key .. "#" .. number] do
number += 1
end
local unique = key .. "#" .. number
seenKeys[unique] = true
return unique
end
local function node(rawNode: any, parentKey: string?, parentPath: string, siblingCount: { [string]: number }, depth: number): Node?
if type(rawNode) ~= "table" then
note("A broken object in " .. parentPath .. " was left out.")
return nil
end
local className = rawNode.className
local name = text(rawNode.name, if type(className) == "string" then className else "Object", 200)
local path = if parentPath == "" then name else parentPath .. " > " .. name
if not Rij.isAllowedClass(className) then
note(path .. ": a " .. tostring(className) .. " isn't something the plugin makes, so it was left out.")
return nil
end
if depth > MAX_DEPTH then
note(path .. ": nested too deep, left out.")
return nil
end
if bundle.count >= MAX_INSTANCES then
note(path .. ": the design has too many objects; the rest were left out.")
return nil
end
bundle.count += 1
local key: string
local attributeId = if type(rawNode.attributes) == "table" then Attributes.find(rawNode.attributes, "id") else nil
if isKey(rawNode.uid) then
key = rawNode.uid
elseif type(attributeId) == "table" and attributeId[1] == "string" and isKey(attributeId[2]) then
key = attributeId[2]
else
local base = if parentKey then parentKey .. ":" .. className else bundle.projectId .. ":" .. className
local seen = (siblingCount[className] or 0) + 1
siblingCount[className] = seen
key = if seen == 1 then base else base .. seen
end
local unique = uniqueKey(key)
if unique ~= key then
note(path .. ": its id is used twice in the file; this copy is treated as a separate object.")
end
local result: Node = {
key = unique,
className = className,
name = name,
properties = {},
attributes = {},
tags = {},
children = {},
hash = nil,
path = path,
}
if type(rawNode.properties) == "table" then
for property, value in rawNode.properties do
if type(property) ~= "string" then
continue
end
local ok, decoded = Rij.decodeProperty(className, property, value)
if ok then
result.properties[property] = decoded
if Rij.isImageRef(decoded) then
local hash = decoded.image
if not imageSeen[hash] then
imageSeen[hash] = true
table.insert(bundle.imageOrder, hash)
end
end
else
note(path .. ": " .. property .. " " .. tostring(decoded) .. ", so it was skipped.")
end
end
end
if type(rawNode.attributes) == "table" then
for attribute, value in rawNode.attributes do
if type(attribute) ~= "string" then
continue
end
local newName = Attributes.current(attribute)
if newName ~= attribute and rawNode.attributes[newName] ~= nil then
continue
end
if newName == ATTR_ID or newName == ATTR_PROJECT then
continue
end
local ok, decoded = Rij.decodeAttribute(newName, value)
if newName == ATTR_HASH then
if ok and type(decoded) == "string" then
result.hash = decoded
end
elseif ok then
result.attributes[newName] = decoded
else
note(path .. ": attribute " .. attribute .. " " .. tostring(decoded) .. ", so it was skipped.")
end
end
end
if type(rawNode.tags) == "table" then
for _, tag in rawNode.tags do
if Rij.isTag(tag) then
if not table.find(result.tags, tag) then
table.insert(result.tags, tag)
end
else
note(path .. ": a tag that isn't valid text was skipped.")
end
end
end
if type(rawNode.children) == "table" then
local NONE: { [string]: boolean } = {}
local allowed: { [string]: boolean }? = if Rij.isHelper(className) then INSIDE_HELPERS[className] or NONE else nil
local counts: { [string]: number } = {}
local dropped = false
for _, rawChild in rawNode.children do
local childClass = if type(rawChild) == "table" then rawChild.className else nil
if allowed and not (type(childClass) == "string" and allowed[childClass]) then
dropped = true
continue
end
local child = node(rawChild, unique, path, counts, depth + 1)
if child then
table.insert(result.children, child)
end
end
if dropped then
local can = {}
for allowedClass in allowed or NONE do
table.insert(can, "a " .. allowedClass)
end
table.sort(can)
note(path .. ": objects inside a " .. className .. " were left out" .. (if #can > 0 then " (only " .. table.concat(can, " or ") .. " can be inside it)." else "."))
end
end
return result
end
local rootCounts: { [string]: number } = {}
local function addRoot(rawRoot: any)
local className = if type(rawRoot) == "table" then rawRoot.className else nil
if type(className) == "string" and Rij.isHelper(className) then
note("A " .. className .. " can't be imported on its own, so it was left out.")
return
end
local root = node(rawRoot, nil, "", rootCounts, 1)
if root then
table.insert(bundle.roots, root)
end
end
for _, rawRoot in raw.roots do
if isHolder(rawRoot) then
local properties: { [string]: any } = {}
if type(rawRoot.properties) == "table" then
for property, value in rawRoot.properties do
local ok, decoded = Rij.decodeProperty("ScreenGui", property, value)
if ok and type(property) == "string" then
properties[property] = decoded
end
end
end
if bundle.holder == nil then
bundle.holder = { name = text(rawRoot.name, "UI", 100), properties = properties }
end
for _, rawChild in (if type(rawRoot.children) == "table" then rawRoot.children else {}) :: { any } do
addRoot(rawChild)
end
continue
end
addRoot(rawRoot)
end
if #bundle.roots == 0 then
Errors.fail("This design file has nothing the plugin can import.", "bundle: no usable roots")
end
for _, hash in bundle.imageOrder do
local info = bundle.images[hash]
if info == nil then
bundle.images[hash] = {
hash = hash,
file = "",
name = "Image",
width = 0,
height = 0,
robloxId = nil,
present = false,
}
table.insert(bundle.warnings, "An image is missing from the file; it will be left empty.")
elseif not info.present and info.robloxId == nil then
table.insert(bundle.warnings, 'The image "' .. info.name .. '" is missing from the file; it will be left empty.')
end
end
return bundle
end
function Bundle.walk(nodes: { Node }, fn: (Node, Node?) -> ())
local function visit(node: Node, parent: Node?)
fn(node, parent)
for _, child in node.children do
visit(child, node)
end
end
for _, root in nodes do
visit(root, nil)
end
end
return Bundle
]]>
-
Checksum
-
Copies
()): () -> ()
own:SetAttribute(Copies.ATTRIBUTE, version)
own:SetAttribute(Copies.RELEASE, release)
local stopped = false
local last: string? = nil
local function check()
if stopped then
return
end
local found = {}
for _, child in place:GetChildren() do
if child ~= own and child.Name == own.Name then
local value = child:GetAttribute(Copies.ATTRIBUTE)
local counted = type(child:GetAttribute(Copies.RELEASE)) == "number"
table.insert(found, if type(value) == "string" and counted then value else "")
end
end
table.sort(found)
local key = #found .. ":" .. table.concat(found, ",")
if key ~= last then
last = key
changed(found)
end
end
local connections = {
place.ChildAdded:Connect(function()
task.defer(check)
task.delay(1, check)
end),
place.ChildRemoved:Connect(function(child: Instance)
if child.Name == own.Name then
check()
end
end),
}
check()
return function()
stopped = true
for _, connection in connections do
connection:Disconnect()
end
end
end
return Copies
]]>
-
Encoding
0 and string.byte(text, size) == 61 then
padding += 1
if string.byte(text, size - 1) == 61 then
padding += 1
end
end
local input = buffer.fromstring(text)
local out = buffer.create(size // 4 * 3 - padding)
local outSize = buffer.len(out)
local at = 0
for index = 0, size - 1, 4 do
local a = VALUES[readu8(input, index) + 1]
local b = VALUES[readu8(input, index + 1) + 1]
local c = VALUES[readu8(input, index + 2) + 1]
local d = VALUES[readu8(input, index + 3) + 1]
local last = index + 4 == size
if a < 0 or b < 0 or (c < 0 and not (last and padding >= 2)) or (d < 0 and not (last and padding >= 1)) then
Errors.fail("The code is damaged.", "base64: a character that is not base64 near " .. index)
end
local n = a * 262144 + b * 4096 + math.max(c, 0) * 64 + math.max(d, 0)
writeu8(out, at, n // 65536)
if at + 1 < outSize then
writeu8(out, at + 1, (n // 256) % 256)
end
if at + 2 < outSize then
writeu8(out, at + 2, n % 256)
end
at += 3
end
return out
end
function Encoding.base64Decode(text: string): buffer
if Encoding.native and service then
local ok, result = pcall(function()
return service:Base64Decode(buffer.fromstring(text))
end)
if ok and typeof(result) == "buffer" then
return result
end
end
return Encoding.base64DecodeLuau(text)
end
function Encoding.sha256(data: buffer): string
if Encoding.native and service then
local ok, digest = pcall(function()
return service:ComputeBufferHash(data, (Enum :: any).HashAlgorithm.Sha256)
end)
if ok and typeof(digest) == "buffer" and buffer.len(digest) == 32 then
local parts = table.create(32, "")
for index = 0, 31 do
parts[index + 1] = string.format("%02x", readu8(digest, index))
end
return table.concat(parts)
end
end
return Sha256.hex(data)
end
return Encoding
]]>
-
Errors
-
Export
number?,
}
function Export.imageId(content: string): number?
local digits = string.match(content, "^%s*rbxassetid://(%d+)%s*$") or string.match(content, "[?&][iI][dD]=(%d+)")
return if digits then tonumber(digits) else nil
end
function Export.isUi(instance: Instance): boolean
return instance:IsA("GuiBase2d") or instance:IsA("UIComponent")
end
function Export.newId(random: Random): string
local chars = table.create(12, "")
for index = 1, 12 do
local at = random:NextInteger(1, #ALPHABET)
chars[index] = string.sub(ALPHABET, at, at)
end
return "n_" .. table.concat(chars)
end
local function validId(value: any): boolean
return type(value) == "string" and #value > 0 and #value <= 120 and string.match(value, "^[%w_%-:%.#]+$") ~= nil
end
local function isHolder(instance: Instance): boolean
return instance:IsA("LayerCollector") and Attributes.get(instance, "holder") == true and Attributes.get(instance, "id") == nil
end
function Export.prepare(selection: { Instance }, random: Random, dryRun: boolean?, uploads: Uploads?, stamp: string?): Prepared
local selected: { [Instance]: boolean } = {}
for _, instance in selection do
selected[instance] = true
end
local roots: { Instance } = {}
for _, instance in selection do
local ancestor = instance.Parent
local inside = false
while ancestor do
if selected[ancestor] then
inside = true
break
end
ancestor = ancestor.Parent
end
if inside then
continue
end
local hasUi = Export.isUi(instance)
if not hasUi then
for _, descendant in instance:GetDescendants() do
if Export.isUi(descendant) then
hasUi = true
break
end
end
end
if hasUi then
table.insert(roots, instance)
end
end
local prepared: Prepared = { roots = roots, count = 0, assigned = 0, cleared = 0, stamped = 0 }
local used: { [string]: boolean } = {}
local function checkImage(instance: Instance)
if uploads == nil or not (instance:IsA("ImageLabel") or instance:IsA("ImageButton")) then
return
end
local hash: any = Attributes.get(instance, "image")
if type(hash) ~= "string" then
return
end
local uploaded = uploads:get(hash)
local content: any = (instance :: any).Image
if uploaded == nil or (type(content) == "string" and Export.imageId(content) == uploaded) then
return
end
if not dryRun then
instance:SetAttribute(ATTR_IMAGE, nil)
if OLD_IMAGE ~= ATTR_IMAGE then
instance:SetAttribute(OLD_IMAGE, nil)
end
end
prepared.cleared += 1
end
local function setId(instance: Instance, id: string)
local old = OLD_ID ~= ATTR_ID and instance:GetAttribute(OLD_ID) ~= nil
if instance:GetAttribute(ATTR_ID) ~= id or old then
if not dryRun then
instance:SetAttribute(ATTR_ID, id)
if old then
instance:SetAttribute(OLD_ID, nil)
end
end
prepared.assigned += 1
end
used[id] = true
end
local function helperId(parentId: string, className: string): string
local base = parentId .. ":" .. className
local id = base
local number = 1
while used[id] do
number += 1
id = base .. number
end
return id
end
local function visit(instance: Instance, parentId: string?, oldParentId: string?)
if isHolder(instance) then
for _, child in instance:GetChildren() do
visit(child, nil, nil)
end
return
end
local ownId: string? = nil
local oldId: string? = nil
if Export.isUi(instance) then
prepared.count += 1
local current: any = Attributes.get(instance, "id")
oldId = if validId(current) then current else nil
local id: string
if
parentId
and oldParentId
and oldId
and string.sub(oldId, 1, #oldParentId + 1) == oldParentId .. ":"
and not used[parentId .. ":" .. string.sub(oldId, #oldParentId + 2)]
then
id = parentId .. ":" .. string.sub(oldId, #oldParentId + 2)
elseif instance:IsA("UIComponent") and parentId then
id = helperId(parentId, instance.ClassName)
elseif oldId and not used[oldId] then
id = oldId
else
id = Export.newId(random)
while used[id] do
id = Export.newId(random)
end
end
setId(instance, id)
ownId = id
checkImage(instance)
end
for _, child in instance:GetChildren() do
if ownId then
visit(child, ownId, oldId)
else
visit(child, parentId, oldParentId)
end
end
end
for _, root in roots do
visit(root, nil, nil)
if stamp and root:GetAttribute(ATTR_PLUGIN) ~= stamp then
if not dryRun then
root:SetAttribute(ATTR_PLUGIN, stamp)
end
prepared.stamped += 1
end
end
return prepared
end
function Export.fileName(roots: { Instance }): string
local name = if #roots > 0 then roots[1].Name else "UI"
name = string.gsub(name, '[\\/:%*%?"<>|%c]', "")
name = string.match(name, "^%s*(.-)%s*$") or ""
if name == "" then
name = "UI"
end
return string.sub(name, 1, 80)
end
return Export
]]>
-
History
string?,
finish: (recording: string, commit: boolean) -> (),
}
History.studio = {
begin = function(name: string, displayName: string): string?
return ChangeHistoryService:TryBeginRecording(name, displayName)
end,
finish = function(recording: string, commit: boolean)
ChangeHistoryService:FinishRecording(
recording,
if commit then Enum.FinishRecordingOperation.Commit else Enum.FinishRecordingOperation.Cancel
)
end,
} :: Recorder
function History.run(recorder: Recorder, name: string, displayName: string, fn: () -> ()): (boolean, any)
local recording = recorder.begin(name, displayName)
if recording == nil then
return false, Errors.new("Studio is busy with another change. Try again in a moment.", "history: no recording")
end
local ok, err = xpcall(fn :: any, Errors.handler)
recorder.finish(recording, ok)
return ok, err
end
return History
]]>
-
Images
(boolean, string?),
upload: (self: any, image: Png.Image, name: string, description: string, creator: Creator) -> (number?, UploadError?),
}
export type Cache = {
get: (self: any, hash: string) -> number?,
set: (self: any, hash: string, id: number) -> (),
}
export type Needs = {
known: { [string]: string },
upload: { string },
missing: { string },
}
export type Resolution = {
contents: { [string]: string },
uploaded: number,
reused: number,
missing: number,
blocked: UploadError?,
errors: { string },
cancelled: boolean,
}
export type Options = {
uploader: Uploader,
cache: Cache,
creator: Creator,
description: string,
allowUpload: boolean,
isCancelled: () -> boolean,
progress: (done: number, total: number, text: string) -> (),
clock: () -> number,
wait: (seconds: number) -> (),
}
local function content(id: number): string
return "rbxassetid://" .. string.format("%d", id)
end
local function nameCharacter(code: number): boolean
return (code >= 48 and code <= 57)
or (code >= 65 and code <= 90)
or (code >= 97 and code <= 122)
or code == 32
or code == 45
or code == 95
or code == 46
or code == 40
or code == 41
or (code >= 0xC0 and code < 0x2000)
or (code >= 0x3040 and code < 0xE000)
or (code >= 0xF900 and code < 0xFE00)
or (code >= 0xFF10 and code < 0xFFF0)
end
function Images.assetName(name: string): string
local characters: { string } = {}
local ok = pcall(function()
for _, code in utf8.codes(name) do
if code == 9 or code == 10 or code == 13 then
code = 32
end
if nameCharacter(code) then
table.insert(characters, utf8.char(code))
end
end
end)
if not ok then
characters = {}
for character in string.gmatch(name, "[%w %-_%.%(%)]") do
table.insert(characters, character)
end
end
local clean = string.gsub(table.concat(characters), "%s+", " ")
clean = string.match(clean, "^%s*(.-)%s*$") or ""
if clean == "" then
return "Image"
end
local short = {}
for _, code in utf8.codes(clean) do
if #short == 50 then
break
end
table.insert(short, utf8.char(code))
end
return (string.gsub(table.concat(short), "%s+$", ""))
end
function Images.needs(bundle: Bundle.Bundle, cache: Cache): Needs
local needs: Needs = { known = {}, upload = {}, missing = {} }
for _, hash in bundle.imageOrder do
local info = bundle.images[hash]
local cached = cache:get(hash)
if info and info.robloxId then
needs.known[hash] = content(info.robloxId)
elseif cached then
needs.known[hash] = content(cached)
elseif info and info.present then
table.insert(needs.upload, hash)
else
table.insert(needs.missing, hash)
end
end
return needs
end
function Images.load(bundle: Bundle.Bundle, hash: string): Png.Image
local info = bundle.images[hash]
local entry = info and Zip.find(bundle.archive, info.file)
if info == nil or entry == nil then
Errors.fail("An image is missing from the file.", "images: no entry for " .. hash)
end
local bytes = Zip.read(bundle.archive, entry :: Zip.Entry)
if Encoding.sha256(bytes) ~= hash then
Errors.fail(
'The image "' .. (info :: Bundle.ImageInfo).name .. '" in the file is damaged. Export the design again.',
"images: SHA-256 mismatch for " .. hash
)
end
local image = Png.decode(bytes)
if image.width > Images.MAX_SIZE or image.height > Images.MAX_SIZE then
Errors.fail(
string.format(
'The image "%s" is %d x %d; Roblox takes at most %d x %d from a plugin.',
(info :: Bundle.ImageInfo).name,
image.width,
image.height,
Images.MAX_SIZE,
Images.MAX_SIZE
),
"images: too big " .. hash
)
end
return image
end
function Images.resolve(bundle: Bundle.Bundle, options: Options): Resolution
local needs = Images.needs(bundle, options.cache)
local resolution: Resolution = {
contents = {},
uploaded = 0,
reused = 0,
missing = #needs.missing,
blocked = nil,
errors = {},
cancelled = false,
}
for hash, value in needs.known do
resolution.contents[hash] = value
resolution.reused += 1
end
local total = #needs.upload
if total == 0 then
return resolution
end
if not options.allowUpload then
resolution.missing += total
return resolution
end
local ok, reason = options.uploader:check()
if not ok then
resolution.blocked = { kind = "blocked", message = reason or "Uploads are not available." }
resolution.missing += total
return resolution
end
local recent: { number } = {}
local function waitForLimit(done: number)
while true do
local now = options.clock()
while #recent > 0 and now - recent[1] >= Images.RATE_WINDOW do
table.remove(recent, 1)
end
if #recent < Images.RATE_LIMIT or options.isCancelled() then
return
end
local seconds = math.ceil(Images.RATE_WINDOW - (now - recent[1]))
options.progress(done, total, string.format("Roblox allows %d uploads a minute. Going on in %d s…", Images.RATE_LIMIT, seconds))
options.wait(1)
end
end
for done, hash in needs.upload do
if options.isCancelled() then
resolution.cancelled = true
resolution.missing += total - done + 1
break
end
local info = bundle.images[hash]
options.progress(done - 1, total, string.format('Uploading "%s" (%d of %d)', info.name, done, total))
options.wait(0)
local loaded, image = xpcall(Images.load, Errors.handler, bundle, hash)
if not loaded then
table.insert(resolution.errors, Errors.message(image))
resolution.missing += 1
continue
end
local id: number? = nil
local failure: UploadError? = nil
for attempt = 0, Images.RETRIES do
waitForLimit(done - 1)
if options.isCancelled() then
break
end
table.insert(recent, options.clock())
id, failure = options.uploader:upload(image, Images.assetName(info.name), options.description, options.creator)
if id or failure == nil or failure.kind == "blocked" or attempt == Images.RETRIES then
break
end
local pause = if failure.kind == "limit" then 20 else 5 * (attempt + 1)
options.progress(done - 1, total, string.format('Retrying "%s" in %d s…', info.name, pause))
options.wait(pause)
end
if id then
options.cache:set(hash, id)
resolution.contents[hash] = content(id)
resolution.uploaded += 1
options.progress(done, total, string.format('Uploaded "%s" (%d of %d)', info.name, done, total))
elseif failure and failure.kind == "blocked" then
resolution.blocked = failure
resolution.missing += total - done + 1
break
elseif options.isCancelled() then
resolution.cancelled = true
resolution.missing += total - done + 1
break
else
resolution.missing += 1
table.insert(
resolution.errors,
string.format('"%s" could not be uploaded: %s', info.name, if failure then failure.message else "no answer from Roblox")
)
end
end
return resolution
end
return Images
]]>
-
Inflate
0 then
counts[length] += 1
end
end
local left = 1
for length = 1, 15 do
left = left * 2 - counts[length]
if left < 0 then
fail("over-subscribed code")
end
end
local offsets = table.create(16, 0)
for length = 1, 15 do
offsets[length + 1] = offsets[length] + counts[length]
end
local symbols = table.create(math.max(count, 1), 0)
for symbol = 0, count - 1 do
local length = lengths[first + symbol]
if length > 0 then
offsets[length] += 1
symbols[offsets[length]] = symbol
end
end
local fast = table.create(FAST_SIZE, 0)
local code = 0
local index = 1
for length = 1, 15 do
for _ = 1, counts[length] do
if length <= FAST_BITS then
local reversed = 0
local value = code
for _ = 1, length do
reversed = reversed * 2 + band(value, 1)
value = rshift(value, 1)
end
local entry = symbols[index] * 16 + length
local step = lshift(1, length)
for slot = reversed, FAST_SIZE - 1, step do
fast[slot + 1] = entry
end
end
code += 1
index += 1
end
code *= 2
end
return { fast = fast, counts = counts, symbols = symbols }
end
local function bits(s: State, n: number): number
while s.bitcnt < n do
local byte = 0
if s.pos < s.stop then
byte = readu8(s.src, s.pos)
else
s.padded += 1
end
s.pos += 1
s.bitbuf = bor(s.bitbuf, lshift(byte, s.bitcnt))
s.bitcnt += 8
end
local value = band(s.bitbuf, lshift(1, n) - 1)
s.bitbuf = rshift(s.bitbuf, n)
s.bitcnt -= n
return value
end
local function decodeSymbol(s: State, h: Huffman): number
while s.bitcnt <= 24 do
local byte = 0
if s.pos < s.stop then
byte = readu8(s.src, s.pos)
else
s.padded += 1
end
s.pos += 1
s.bitbuf = bor(s.bitbuf, lshift(byte, s.bitcnt))
s.bitcnt += 8
end
local entry = h.fast[band(s.bitbuf, FAST_MASK) + 1]
if entry > 0 then
local length = band(entry, 15)
s.bitbuf = rshift(s.bitbuf, length)
s.bitcnt -= length
return rshift(entry, 4)
end
local code, firstCode, index = 0, 0, 0
local counts = h.counts
for length = 1, 15 do
code = bor(code, band(s.bitbuf, 1))
s.bitbuf = rshift(s.bitbuf, 1)
s.bitcnt -= 1
local count = counts[length]
if code - count < firstCode then
return h.symbols[index + code - firstCode + 1]
end
index += count
firstCode = (firstCode + count) * 2
code *= 2
end
return fail("invalid code")
end
local FIXED_LITERALS: Huffman, FIXED_DISTANCES: Huffman
do
local lengths = table.create(288, 8)
for symbol = 144, 255 do
lengths[symbol + 1] = 9
end
for symbol = 256, 279 do
lengths[symbol + 1] = 7
end
FIXED_LITERALS = build(lengths, 1, 288)
FIXED_DISTANCES = build(table.create(30, 5), 1, 30)
end
local function readDynamic(s: State): (Huffman, Huffman)
local literalCount = bits(s, 5) + 257
local distanceCount = bits(s, 5) + 1
local codeCount = bits(s, 4) + 4
if literalCount > 286 or distanceCount > 30 then
fail("too many codes")
end
local codeLengths = table.create(19, 0)
for index = 1, codeCount do
codeLengths[CODE_LENGTH_ORDER[index] + 1] = bits(s, 3)
end
local lengthCode = build(codeLengths, 1, 19)
local total = literalCount + distanceCount
local lengths = table.create(total, 0)
local index = 1
while index <= total do
local symbol = decodeSymbol(s, lengthCode)
if symbol < 16 then
lengths[index] = symbol
index += 1
else
local value, repeats = 0, 0
if symbol == 16 then
if index == 1 then
fail("repeat without a length")
end
value = lengths[index - 1]
repeats = 3 + bits(s, 2)
elseif symbol == 17 then
repeats = 3 + bits(s, 3)
else
repeats = 11 + bits(s, 7)
end
if index + repeats - 1 > total then
fail("too many code lengths")
end
for _ = 1, repeats do
lengths[index] = value
index += 1
end
end
end
if lengths[257] == 0 then
fail("no end-of-block code")
end
return build(lengths, 1, literalCount), build(lengths, literalCount + 1, distanceCount)
end
local function storedBlock(s: State, out: buffer, outPos: number, outEnd: number): number
local drop = s.bitcnt % 8
s.bitbuf = rshift(s.bitbuf, drop)
s.bitcnt -= drop
local length = bits(s, 16)
local check = bits(s, 16)
if bxor(length, 0xFFFF) ~= check then
fail("stored block length check")
end
s.pos -= s.bitcnt // 8
s.bitbuf = 0
s.bitcnt = 0
if s.pos > s.stop or s.pos + length > s.stop then
fail("stored block runs past the end")
end
s.padded = 0
if outPos + length > outEnd then
fail("more data than expected")
end
bcopy(out, outPos, s.src, s.pos, length)
s.pos += length
return outPos + length
end
local function decodeBlock(s: State, out: buffer, outPos: number, outEnd: number, lit: Huffman, dist: Huffman): number
local src, pos, stop = s.src, s.pos, s.stop
local bitbuf, bitcnt, padded = s.bitbuf, s.bitcnt, s.padded
local litFast, litCounts, litSymbols = lit.fast, lit.counts, lit.symbols
local distFast, distCounts, distSymbols = dist.fast, dist.counts, dist.symbols
while true do
while bitcnt <= 24 do
if pos < stop then
bitbuf = bor(bitbuf, lshift(readu8(src, pos), bitcnt))
else
padded += 1
if padded > 8 then
fail("ends too early")
end
end
pos += 1
bitcnt += 8
end
local symbol: number
local entry = litFast[band(bitbuf, FAST_MASK) + 1]
if entry > 0 then
local length = band(entry, 15)
symbol = rshift(entry, 4)
bitbuf = rshift(bitbuf, length)
bitcnt -= length
else
symbol = -1
local code, firstCode, index = 0, 0, 0
for length = 1, 15 do
code = bor(code, band(bitbuf, 1))
bitbuf = rshift(bitbuf, 1)
bitcnt -= 1
local count = litCounts[length]
if code - count < firstCode then
symbol = litSymbols[index + code - firstCode + 1]
break
end
index += count
firstCode = (firstCode + count) * 2
code *= 2
end
if symbol < 0 then
fail("invalid literal code")
end
end
if symbol < 256 then
if outPos >= outEnd then
fail("more data than expected")
end
writeu8(out, outPos, symbol)
outPos += 1
elseif symbol == 256 then
break
else
symbol -= 257
if symbol >= 29 then
fail("invalid length code")
end
local length = LENGTH_BASE[symbol + 1]
local extra = LENGTH_EXTRA[symbol + 1]
if extra > 0 then
length += band(bitbuf, lshift(1, extra) - 1)
bitbuf = rshift(bitbuf, extra)
bitcnt -= extra
end
while bitcnt <= 24 do
if pos < stop then
bitbuf = bor(bitbuf, lshift(readu8(src, pos), bitcnt))
else
padded += 1
if padded > 8 then
fail("ends too early")
end
end
pos += 1
bitcnt += 8
end
local distSymbol: number
local distEntry = distFast[band(bitbuf, FAST_MASK) + 1]
if distEntry > 0 then
local codeLength = band(distEntry, 15)
distSymbol = rshift(distEntry, 4)
bitbuf = rshift(bitbuf, codeLength)
bitcnt -= codeLength
else
distSymbol = -1
local code, firstCode, index = 0, 0, 0
for codeLength = 1, 15 do
code = bor(code, band(bitbuf, 1))
bitbuf = rshift(bitbuf, 1)
bitcnt -= 1
local count = distCounts[codeLength]
if code - count < firstCode then
distSymbol = distSymbols[index + code - firstCode + 1]
break
end
index += count
firstCode = (firstCode + count) * 2
code *= 2
end
if distSymbol < 0 then
fail("invalid distance code")
end
end
if distSymbol >= 30 then
fail("invalid distance code")
end
local distance = DIST_BASE[distSymbol + 1]
local distExtra = DIST_EXTRA[distSymbol + 1]
if distExtra > 0 then
while bitcnt < distExtra do
if pos < stop then
bitbuf = bor(bitbuf, lshift(readu8(src, pos), bitcnt))
else
padded += 1
if padded > 8 then
fail("ends too early")
end
end
pos += 1
bitcnt += 8
end
distance += band(bitbuf, lshift(1, distExtra) - 1)
bitbuf = rshift(bitbuf, distExtra)
bitcnt -= distExtra
end
if distance > outPos then
fail("distance too far back")
end
if outPos + length > outEnd then
fail("more data than expected")
end
local from = outPos - distance
if length < 16 then
for offset = 0, length - 1 do
writeu8(out, outPos + offset, readu8(out, from + offset))
end
outPos += length
elseif distance >= length then
bcopy(out, outPos, out, from, length)
outPos += length
else
local remaining = length
while remaining > 0 do
local chunk = math.min(remaining, outPos - from)
bcopy(out, outPos, out, from, chunk)
outPos += chunk
remaining -= chunk
end
end
end
end
s.pos, s.bitbuf, s.bitcnt, s.padded = pos, bitbuf, bitcnt, padded
return outPos
end
local Inflate = {}
function Inflate.raw(src: buffer, offset: number, length: number, outSize: number): (buffer, number)
if offset < 0 or length < 0 or offset + length > buffer.len(src) then
fail("bad input range")
end
local s: State = { src = src, pos = offset, stop = offset + length, bitbuf = 0, bitcnt = 0, padded = 0 }
local out = buffer.create(outSize)
local outPos = 0
while true do
local final = bits(s, 1)
local kind = bits(s, 2)
if kind == 0 then
outPos = storedBlock(s, out, outPos, outSize)
elseif kind == 1 then
outPos = decodeBlock(s, out, outPos, outSize, FIXED_LITERALS, FIXED_DISTANCES)
elseif kind == 2 then
local literals, distances = readDynamic(s)
outPos = decodeBlock(s, out, outPos, outSize, literals, distances)
else
fail("invalid block type")
end
if s.padded * 8 > s.bitcnt then
fail("ends too early")
end
if final == 1 then
break
end
end
if outPos ~= outSize then
fail(string.format("%d bytes instead of %d", outPos, outSize))
end
local used = s.pos - offset - s.bitcnt // 8
return out, used
end
function Inflate.zlib(src: buffer, offset: number, length: number, outSize: number): buffer
if length < 6 then
fail("zlib stream too short")
end
local cmf, flg = readu8(src, offset), readu8(src, offset + 1)
if band(cmf, 15) ~= 8 or rshift(cmf, 4) > 7 or (cmf * 256 + flg) % 31 ~= 0 then
fail("not a zlib stream")
end
if band(flg, 0x20) ~= 0 then
fail("zlib preset dictionary")
end
local out, used = Inflate.raw(src, offset + 2, length - 2, outSize)
local checkAt = offset + 2 + used
if checkAt + 4 > offset + length then
fail("zlib checksum missing")
end
local expected = bit32.byteswap(buffer.readu32(src, checkAt))
if Checksum.adler32(out, 0, outSize) ~= expected then
fail("zlib checksum mismatch")
end
return out
end
return Inflate
]]>
-
Paste
(NEWEST[name] or 0) then
Errors.fail(
string.format(
"This code was made by a newer version of %s. Update %s: download it again from %s's export window.",
TOOL,
Brand.pluginName,
TOOL
),
"paste: version " .. tostring(version),
"update"
)
end
local part, parts, id, data = string.match(code, "^" .. name .. "%d+:(%d+)/(%d+):(%x+):([%w%+/=]*)$")
local partNumber, partCount = tonumber(part), tonumber(parts)
if version == nil or not READS[name .. version] or partNumber == nil or partCount == nil or id == nil or data == nil then
Errors.fail(DAMAGED, "paste: bad code " .. string.sub(code, 1, 40))
end
local number, count = partNumber :: number, partCount :: number
if #(id :: string) ~= 8 or number < 1 or count < 1 or number > count or count > MAX_PARTS or data == "" then
Errors.fail(DAMAGED, "paste: bad header " .. string.sub(code, 1, 40))
end
table.insert(found, { part = number, parts = count, id = string.lower(id :: string), data = data :: string })
start, name = nextStart, nextName
end
return found
end
function Paste.collector(): Collector
return { id = nil, parts = 0, data = {} }
end
local function status(collector: Collector, restarted: boolean): Status
local missing = {}
local have = 0
for number = 1, collector.parts do
if collector.data[number] then
have += 1
else
table.insert(missing, number)
end
end
return { complete = collector.parts > 0 and #missing == 0, have = have, need = collector.parts, missing = missing, restarted = restarted }
end
function Paste.add(collector: Collector, parts: { Part }): Status
local restarted = false
for _, part in parts do
if collector.id ~= part.id or collector.parts ~= part.parts then
restarted = restarted or (collector.id ~= nil and next(collector.data) ~= nil)
collector.id = part.id
collector.parts = part.parts
collector.data = {}
end
collector.data[part.part] = part.data
end
return status(collector, restarted)
end
function Paste.assemble(collector: Collector): buffer
local pieces = table.create(collector.parts, "")
for number = 1, collector.parts do
local piece = collector.data[number]
if piece == nil then
Errors.fail("Part " .. number .. " of the code is still missing.", "paste: part " .. number .. " missing")
end
pieces[number] = piece :: string
end
local zip = Encoding.base64Decode(table.concat(pieces))
if string.sub(Encoding.sha256(zip), 1, 8) ~= collector.id then
Errors.fail(
"The code is incomplete or damaged (maybe it was cut off when pasting). Copy it again in " .. TOOL .. " and paste it here.",
"paste: SHA-256 does not match the id " .. tostring(collector.id)
)
end
return zip
end
function Paste.describe(state: Status): string
local names = {}
for _, number in state.missing do
table.insert(names, "part " .. number)
end
local list = if #names <= 1 then names[1] or "" else table.concat(names, ", ", 1, #names - 1) .. " and " .. names[#names]
return string.format("%d of %d parts pasted. Still needed: %s.", state.have, state.need, list)
end
return Paste
]]>
-
Png
0 then
for i = first, last do
writeu8(raw, i, band(readu8(raw, i) + readu8(raw, i - stride), 255))
end
end
elseif filter == 3 then
if y > 0 then
for i = first, math.min(first + bpp - 1, last) do
writeu8(raw, i, band(readu8(raw, i) + rshift(readu8(raw, i - stride), 1), 255))
end
for i = first + bpp, last do
writeu8(raw, i, band(readu8(raw, i) + rshift(readu8(raw, i - bpp) + readu8(raw, i - stride), 1), 255))
end
else
for i = first + bpp, last do
writeu8(raw, i, band(readu8(raw, i) + rshift(readu8(raw, i - bpp), 1), 255))
end
end
elseif filter == 4 then
if y > 0 then
for i = first, math.min(first + bpp - 1, last) do
writeu8(raw, i, band(readu8(raw, i) + readu8(raw, i - stride), 255))
end
for i = first + bpp, last do
local a = readu8(raw, i - bpp)
local b = readu8(raw, i - stride)
local c = readu8(raw, i - stride - bpp)
local p = a + b - c
local pa = math.abs(p - a)
local pb = math.abs(p - b)
local pc = math.abs(p - c)
local predictor = if pa <= pb and pa <= pc then a elseif pb <= pc then b else c
writeu8(raw, i, band(readu8(raw, i) + predictor, 255))
end
else
for i = first + bpp, last do
writeu8(raw, i, band(readu8(raw, i) + readu8(raw, i - bpp), 255))
end
end
else
fail("unknown row filter " .. filter)
end
end
end
function Png.decode(data: buffer): Image
local size = buffer.len(data)
local info = Png.info(data)
local width, height, depth, colorType = info.width, info.height, info.bitDepth, info.colorType
if width < 1 or height < 1 or width > MAX_SIDE or height > MAX_SIDE or width * height > MAX_PIXELS then
Errors.fail("An image in the file is too big to read (" .. width .. " x " .. height .. ").", "png: size")
end
if CHANNELS[colorType] == nil or not DEPTHS[colorType][depth] then
fail("color type " .. colorType .. " with " .. depth .. " bits")
end
if readu8(data, 26) ~= 0 or readu8(data, 27) ~= 0 then
fail("unknown compression or filter method")
end
if info.interlace ~= 0 then
Errors.fail(
"An image in the file is interlaced, which " .. Brand.pluginName .. " can't read. Export the design again from " .. Brand.productName .. ".",
"png: interlaced"
)
end
local palette: buffer? = nil
local paletteCount = 0
local keyGray, keyRed, keyGreen, keyBlue = -1, -1, -1, -1
local parts: { { number } } = {}
local compressedSize = 0
local pos = 8
local ended = false
while pos + 12 <= size do
local length = u32be(data, pos)
if length > size - pos - 12 then
fail("chunk runs past the end")
end
local chunkType = buffer.readstring(data, pos + 4, 4)
local body = pos + 8
if Checksum.crc32(data, pos + 4, length + 4) ~= u32be(data, body + length) then
fail("checksum of " .. chunkType)
end
if chunkType == "PLTE" then
if length % 3 ~= 0 or length == 0 or length > 768 then
fail("palette size")
end
local entries = buffer.create(1024)
paletteCount = length // 3
for index = 0, paletteCount - 1 do
writeu8(entries, index * 4, readu8(data, body + index * 3))
writeu8(entries, index * 4 + 1, readu8(data, body + index * 3 + 1))
writeu8(entries, index * 4 + 2, readu8(data, body + index * 3 + 2))
writeu8(entries, index * 4 + 3, 255)
end
palette = entries
elseif chunkType == "tRNS" then
if colorType == 3 then
local entries = palette
if entries == nil or length > paletteCount then
fail("transparency before or longer than the palette")
else
for index = 0, length - 1 do
writeu8(entries, index * 4 + 3, readu8(data, body + index))
end
end
elseif colorType == 0 and length >= 2 then
keyGray = u16be(data, body)
elseif colorType == 2 and length >= 6 then
keyRed, keyGreen, keyBlue = u16be(data, body), u16be(data, body + 2), u16be(data, body + 4)
end
elseif chunkType == "IDAT" then
table.insert(parts, { body, length })
compressedSize += length
elseif chunkType == "IEND" then
ended = true
break
elseif chunkType ~= "IHDR" and band(readu8(data, pos + 4), 0x20) == 0 then
fail("unknown required chunk " .. chunkType)
end
pos = body + length + 4
end
if not ended or #parts == 0 then
fail("image data missing")
end
if colorType == 3 and palette == nil then
fail("palette missing")
end
local channels = CHANNELS[colorType]
local bitsPerPixel = channels * depth
local rowBytes = (width * bitsPerPixel + 7) // 8
local bpp = math.max(1, bitsPerPixel // 8)
local rawSize = height * (rowBytes + 1)
local raw: buffer
if #parts == 1 then
raw = Inflate.zlib(data, parts[1][1], parts[1][2], rawSize)
else
local joined = buffer.create(compressedSize)
local at = 0
for _, part in parts do
buffer.copy(joined, at, data, part[1], part[2])
at += part[2]
end
raw = Inflate.zlib(joined, 0, compressedSize, rawSize)
end
unfilter(raw, height, rowBytes, bpp)
local pixels = buffer.create(width * height * 4)
local stride = rowBytes + 1
for y = 0, height - 1 do
local row = y * stride + 1
local out = y * width * 4
if colorType == 6 and depth == 8 then
buffer.copy(pixels, out, raw, row, width * 4)
elseif colorType == 2 and depth == 8 then
for x = 0, width - 1 do
local i = row + x * 3
local r, g, b = readu8(raw, i), readu8(raw, i + 1), readu8(raw, i + 2)
local o = out + x * 4
writeu8(pixels, o, r)
writeu8(pixels, o + 1, g)
writeu8(pixels, o + 2, b)
writeu8(pixels, o + 3, if r == keyRed and g == keyGreen and b == keyBlue then 0 else 255)
end
elseif colorType == 3 then
local entries = palette :: buffer
local perByte = 8 // depth
local mask = 2 ^ depth - 1
for x = 0, width - 1 do
local index: number
if depth == 8 then
index = readu8(raw, row + x)
else
local byte = readu8(raw, row + x // perByte)
local shift = 8 - depth * (x % perByte + 1)
index = band(rshift(byte, shift), mask)
end
if index >= paletteCount then
fail("palette index out of range")
end
buffer.writeu32(pixels, out + x * 4, buffer.readu32(entries, index * 4))
end
elseif colorType == 6 then
for x = 0, width - 1 do
local i = row + x * 8
local o = out + x * 4
writeu8(pixels, o, readu8(raw, i))
writeu8(pixels, o + 1, readu8(raw, i + 2))
writeu8(pixels, o + 2, readu8(raw, i + 4))
writeu8(pixels, o + 3, readu8(raw, i + 6))
end
elseif colorType == 2 then
for x = 0, width - 1 do
local i = row + x * 6
local o = out + x * 4
local r, g, b = u16be(raw, i), u16be(raw, i + 2), u16be(raw, i + 4)
writeu8(pixels, o, rshift(r, 8))
writeu8(pixels, o + 1, rshift(g, 8))
writeu8(pixels, o + 2, rshift(b, 8))
writeu8(pixels, o + 3, if r == keyRed and g == keyGreen and b == keyBlue then 0 else 255)
end
elseif colorType == 4 then
local step = if depth == 8 then 2 else 4
local alphaAt = if depth == 8 then 1 else 2
for x = 0, width - 1 do
local i = row + x * step
local o = out + x * 4
local gray = readu8(raw, i)
writeu8(pixels, o, gray)
writeu8(pixels, o + 1, gray)
writeu8(pixels, o + 2, gray)
writeu8(pixels, o + 3, readu8(raw, i + alphaAt))
end
else
for x = 0, width - 1 do
local sample: number, gray: number
if depth == 16 then
sample = u16be(raw, row + x * 2)
gray = rshift(sample, 8)
elseif depth == 8 then
sample = readu8(raw, row + x)
gray = sample
else
local perByte = 8 // depth
local byte = readu8(raw, row + x // perByte)
local shift = 8 - depth * (x % perByte + 1)
sample = band(rshift(byte, shift), 2 ^ depth - 1)
gray = sample * 255 // (2 ^ depth - 1)
end
local o = out + x * 4
writeu8(pixels, o, gray)
writeu8(pixels, o + 1, gray)
writeu8(pixels, o + 2, gray)
writeu8(pixels, o + 3, if sample == keyGray then 0 else 255)
end
end
end
return { width = width, height = height, pixels = pixels }
end
return Png
]]>
-
Rij
= HUGE then
return math.huge
elseif value <= -HUGE then
return -math.huge
end
return value
end
local function isNumber(value: any): boolean
return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
end
local function isInteger(value: any): boolean
return isNumber(value) and value == math.floor(value) and value >= -2147483648 and value <= 2147483647
end
function Rij.isContent(value: any): boolean
if type(value) ~= "string" then
return false
end
if value == "" then
return true
end
if string.match(value, "^rbxassetid://%d+$") then
return true
end
if string.match(value, "^rbxasset://[%w_%-%./@]+$") and not string.find(value, "..", 1, true) then
return true
end
if string.match(value, "^rbxthumb://[%w_%-=&%.]+$") then
return true
end
if string.match(value, "^https?://www%.roblox%.com/asset/?%?id=%d+$") then
return true
end
return false
end
local function isFontFamily(value: any): boolean
return type(value) == "string"
and (
string.match(value, "^rbxasset://fonts/families/[%w_%-]+%.json$") ~= nil
or string.match(value, "^rbxassetid://%d+$") ~= nil
)
end
local function enumItem(enumType: any, item: any): EnumItem?
if type(enumType) ~= "string" or (type(item) ~= "string" and type(item) ~= "number") then
return nil
end
local ok, enum = pcall(function()
return (Enum :: any)[enumType]
end)
if not ok or enum == nil then
return nil
end
local found
if type(item) == "string" then
found = enum:FromName(item)
else
found = enum:FromValue(item)
end
return found
end
local function color(hex: any): Color3?
if type(hex) ~= "string" or not string.match(hex, "^#?%x%x%x%x%x%x$") then
return nil
end
return Color3.fromHex(hex)
end
local function keypointTimes(points: { any }): boolean
if #points < 2 or #points > 20 then
return false
end
local last = -1
for index, point in points do
local t = point[1]
if not isNumber(t) or t < last or t < 0 or t > 1 then
return false
end
if (index == 1 and t ~= 0) or (index == #points and t ~= 1) then
return false
end
last = t
end
return true
end
local function keypoints(raw: { any }): { any }?
local points = {}
for index = 2, #raw do
local point = raw[index]
if type(point) ~= "table" then
return nil
end
table.insert(points, point)
end
return points
end
function Rij.decode(raw: any): (boolean, any)
if type(raw) ~= "table" or type(raw[1]) ~= "string" then
return false, "is not a value"
end
local kind = raw[1]
local a, b, c, d = raw[2], raw[3], raw[4], raw[5]
if kind == "bool" then
if type(a) == "boolean" then
return true, a
end
elseif kind == "number" then
if isNumber(a) then
return true, endless(a)
end
elseif kind == "int" then
if isInteger(a) then
return true, a
end
elseif kind == "string" then
if type(a) == "string" then
return true, a
end
elseif kind == "UDim" then
if isNumber(a) and isNumber(b) then
return true, UDim.new(a, b)
end
elseif kind == "UDim2" then
if isNumber(a) and isNumber(b) and isNumber(c) and isNumber(d) then
return true, UDim2.new(a, b, c, d)
end
elseif kind == "Vector2" then
if isNumber(a) and isNumber(b) then
return true, Vector2.new(endless(a), endless(b))
end
elseif kind == "Vector3" then
if isNumber(a) and isNumber(b) and isNumber(c) then
return true, Vector3.new(a, b, c)
end
elseif kind == "Color3" then
local value = color(a)
if value then
return true, value
end
elseif kind == "Enum" then
local item = enumItem(a, b)
if item then
return true, item
end
return false, "is not a known Enum." .. tostring(a) .. " item"
elseif kind == "Font" then
local weight = if b == nil then Enum.FontWeight.Regular else enumItem("FontWeight", b)
local style = if c == nil then Enum.FontStyle.Normal else enumItem("FontStyle", c)
if isFontFamily(a) and weight and style then
return true, Font.new(a, weight :: any, style :: any)
end
elseif kind == "ColorSequence" then
local points = keypoints(raw)
if points and keypointTimes(points) then
local list = {}
for _, point in points do
local value = color(point[2])
if not value then
return false, "has a bad color"
end
table.insert(list, ColorSequenceKeypoint.new(point[1], value))
end
local ok, value = pcall(function()
return ColorSequence.new(list)
end)
if ok then
return true, value
end
end
elseif kind == "NumberSequence" then
local points = keypoints(raw)
if points and keypointTimes(points) then
local list = {}
for _, point in points do
local value, envelope = point[2], point[3] or 0
if not isNumber(value) or not isNumber(envelope) then
return false, "has a bad number"
end
table.insert(list, NumberSequenceKeypoint.new(point[1], value, envelope))
end
local ok, value = pcall(function()
return NumberSequence.new(list)
end)
if ok then
return true, value
end
end
elseif kind == "NumberRange" then
if isNumber(a) and isNumber(b) and a <= b then
return true, NumberRange.new(endless(a), endless(b))
end
elseif kind == "Rect" then
if isNumber(a) and isNumber(b) and isNumber(c) and isNumber(d) then
return true, Rect.new(a, b, c, d)
end
elseif kind == "Content" then
if Rij.isContent(a) then
return true, a
end
return false, "is not a Roblox image address"
elseif kind == "Image" then
if type(a) == "string" and #a == 64 and string.match(a, "^%x+$") then
local ref: ImageRef = { image = string.lower(a) }
return true, ref
end
return false, "is not an image of the file"
else
return false, "has an unknown type (" .. kind .. ")"
end
return false, "is not a valid " .. kind
end
function Rij.isImageRef(value: any): boolean
return type(value) == "table" and type(value.image) == "string"
end
function Rij.decodeProperty(className: string, property: string, raw: any): (boolean, any)
local specs = SPECS[className]
local spec = specs and specs[property]
if spec == nil then
return false, "isn't a property the plugin sets on a " .. className
end
if type(raw) ~= "table" or type(raw[1]) ~= "string" then
return false, "is not a value"
end
local kind = raw[1]
local accepted = ACCEPTS[spec.kind]
if (accepted and not accepted[kind]) or (accepted == nil and kind ~= spec.kind) then
return false, "should be a " .. spec.kind .. ", not a " .. kind
end
if spec.kind == "Enum" and raw[2] ~= spec.enum then
return false, "should be an Enum." .. tostring(spec.enum)
end
local ok, value = Rij.decode(raw)
if not ok then
return false, value
end
if spec.kind == "int" and not isInteger(value) then
return false, "should be a whole number"
end
if spec.kind == "string" and #value > (spec.max or TEXT_LIMIT) then
return false, "is too long"
end
if spec.kind == "Image" and kind == "string" and not Rij.isContent(value) then
return false, "is not a Roblox image address"
end
return true, value
end
function Rij.decodeAttribute(name: string, raw: any): (boolean, any)
if type(name) ~= "string" or #name == 0 or #name > 100 or not string.match(name, "^[%w_]+$") then
return false, "has a name Roblox doesn't allow"
end
if string.sub(name, 1, 3) == "RBX" then
return false, "has a name Roblox keeps for itself"
end
if type(raw) ~= "table" or not ATTRIBUTE_KINDS[raw[1]] then
return false, "has a type attributes can't hold"
end
return Rij.decode(raw)
end
function Rij.isTag(value: any): boolean
return type(value) == "string" and #value > 0 and #value <= 100 and not string.find(value, "%c")
end
function Rij.isAllowedClass(className: any): boolean
return type(className) == "string" and CLASS_GROUPS[className] ~= nil
end
function Rij.isHelper(className: string): boolean
return HELPERS[className] == true
end
function Rij.isLayerCollector(className: string): boolean
return LAYER_COLLECTORS[className] == true
end
function Rij.spec(className: string, property: string): Spec?
local specs = SPECS[className]
return specs and specs[property]
end
function Rij.designProperties(className: string): { string }
local out = {}
local names = NAMES[className]
if names == nil then
return out
end
for _, property in names do
if SPECS[className][property].design then
table.insert(out, property)
end
end
return out
end
function Rij.isStudioSide(className: string, property: string): boolean
local spec = Rij.spec(className, property)
return spec ~= nil and spec.studio == true
end
function Rij.properties(className: string): { string }
return NAMES[className] or {}
end
function Rij.classes(): { string }
local out = {}
for className in CLASS_GROUPS do
table.insert(out, className)
end
table.sort(out)
return out
end
return Rij
]]>
-
Settings
any,
set: (key: string, value: any) -> (),
}
export type LastImport = {
project: string,
at: number,
added: number,
updated: number,
removed: number,
uploaded: number,
empty: number,
}
export type Release = {
version: string,
release: number,
notes: string?,
url: string,
}
export type UpdateState = {
checkedAt: number?,
newest: Release?,
later: number?,
off: boolean,
}
local KEY_TARGET = "NKD_Target"
local KEY_CREATOR = "NKD_Creator"
local KEY_IMAGES = "NKD_UploadedImages"
local KEY_LAST = "NKD_LastImport"
local KEY_VERSION = "NKD_SettingsVersion"
local KEY_UPDATES = "NKD_Updates"
Settings.TARGETS = { "file", "StarterGui", "ReplicatedStorage", "ServerStorage" }
Settings.VERSION = 1
local MIGRATIONS: { [number]: (storage: Storage) -> () } = {
[1] = function(_storage: Storage) end,
}
export type Settings = typeof(setmetatable({} :: { storage: Storage }, Settings))
function Settings.new(storage: Storage): Settings
return setmetatable({ storage = storage }, Settings)
end
function Settings.migrate(self: Settings): number
local stored = self.storage.get(KEY_VERSION)
local from = if type(stored) == "number" and stored == stored and stored >= 0 then math.floor(stored) else 0
if from >= Settings.VERSION then
return from
end
for version = from + 1, Settings.VERSION do
local step = MIGRATIONS[version]
if step then
step(self.storage)
end
self.storage.set(KEY_VERSION, version)
end
return Settings.VERSION
end
function Settings.pluginStorage(plugin: Plugin): Storage
return {
get = function(key: string): any
local ok, value = pcall(plugin.GetSetting, plugin, key)
return if ok then value else nil
end,
set = function(key: string, value: any)
pcall(plugin.SetSetting, plugin, key, value)
end,
}
end
function Settings.memoryStorage(): Storage
local values: { [string]: any } = {}
return {
get = function(key: string): any
return values[key]
end,
set = function(key: string, value: any)
values[key] = value
end,
}
end
function Settings.target(self: Settings): string
local value = self.storage.get(KEY_TARGET)
return if type(value) == "string" and table.find(Settings.TARGETS, value) then value else "file"
end
function Settings.setTarget(self: Settings, value: string)
if table.find(Settings.TARGETS, value) then
self.storage.set(KEY_TARGET, value)
end
end
function Settings.creator(self: Settings): { kind: string, groupId: number? }
local value = self.storage.get(KEY_CREATOR)
local groupId = nil
if type(value) == "table" and type(value.groupId) == "number" and value.groupId > 0 and value.groupId == math.floor(value.groupId) then
groupId = value.groupId
end
if type(value) == "table" and value.kind == "group" then
return { kind = "group", groupId = groupId }
end
return { kind = "user", groupId = groupId }
end
function Settings.setCreator(self: Settings, kind: string, groupId: number?)
self.storage.set(KEY_CREATOR, { kind = if kind == "group" then "group" else "user", groupId = groupId })
end
local function readImages(self: Settings): { [string]: number }
local value = self.storage.get(KEY_IMAGES)
local out: { [string]: number } = {}
if type(value) == "table" then
for hash, id in value do
if type(hash) == "string" and type(id) == "number" and id > 0 then
out[hash] = id
end
end
end
return out
end
function Settings.imageCache(self: Settings)
local settings = self
return {
get = function(_cache: any, hash: string): number?
return readImages(settings)[hash]
end,
set = function(_cache: any, hash: string, id: number)
local images = readImages(settings)
images[hash] = id
settings.storage.set(KEY_IMAGES, images)
end,
}
end
function Settings.uploadedCount(self: Settings): number
local count = 0
for _ in readImages(self) do
count += 1
end
return count
end
function Settings.forgetUploads(self: Settings)
self.storage.set(KEY_IMAGES, {})
end
function Settings.lastImport(self: Settings): LastImport?
local value = self.storage.get(KEY_LAST)
if type(value) == "table" and type(value.project) == "string" and type(value.at) == "number" then
return {
project = value.project,
at = value.at,
added = tonumber(value.added) or 0,
updated = tonumber(value.updated) or 0,
removed = tonumber(value.removed) or 0,
uploaded = tonumber(value.uploaded) or 0,
empty = tonumber(value.empty) or 0,
}
end
return nil
end
function Settings.setLastImport(self: Settings, value: LastImport)
self.storage.set(KEY_LAST, value)
end
local function count(value: any): number?
if type(value) == "number" and value == value and value >= 1 and value <= 1e6 and math.floor(value) == value then
return value
end
return nil
end
function Settings.updates(self: Settings): UpdateState
local value = self.storage.get(KEY_UPDATES)
local state: UpdateState = { off = false }
if type(value) ~= "table" then
return state
end
local at = value.checkedAt
if type(at) == "number" and at == at and at >= 0 and at < math.huge then
state.checkedAt = at
end
state.later = count(value.later)
state.off = value.off == true
local newest = value.newest
if type(newest) == "table" and type(newest.version) == "string" and count(newest.release) and type(newest.url) == "string" then
state.newest = {
version = newest.version,
release = newest.release,
notes = if type(newest.notes) == "string" then newest.notes else nil,
url = newest.url,
}
end
return state
end
function Settings.setUpdates(self: Settings, state: UpdateState)
local newest = state.newest
self.storage.set(KEY_UPDATES, {
checkedAt = state.checkedAt,
newest = if newest then { version = newest.version, release = newest.release, notes = newest.notes, url = newest.url } else nil,
later = state.later,
off = state.off,
})
end
return Settings
]]>
-
Sha256
-
Ui
(),
importFile: () -> (),
export: () -> (),
confirm: () -> (),
cancel: () -> (),
placeholders: () -> (),
dismiss: () -> (),
setTarget: (value: string) -> (),
setCreator: (kind: string, groupId: number?) -> (),
forgetUploads: () -> (),
hideNotice: (id: string) -> (),
noticeAction: ((id: string, action: string) -> ())?,
setUpdateCheck: ((on: boolean) -> ())?,
}
export type Action = { id: string, label: string, primary: boolean? }
export type State = {
view: string,
title: string,
text: string?,
lines: { string }?,
warnings: { string }?,
notes: { string }?,
steps: { string }?,
progress: number?,
segments: { boolean }?,
tone: string?,
undo: boolean?,
link: string?,
actions: { Action }?,
busy: boolean?,
}
export type SettingsState = {
target: string,
targetChoices: { { value: string, label: string } },
creatorKind: string,
groupId: number?,
userName: string?,
uploaded: number,
updateCheck: boolean?,
}
export type Notice = {
id: string,
title: string,
text: string,
link: string?,
tone: string?,
steps: { string }?,
actions: { Action }?,
}
export type Info = {
pluginName: string,
toolName: string,
guideUrl: string,
version: string?,
copyright: string?,
theme: StudioTheme?,
reducedMotion: boolean?,
}
type Colors = {
dark: boolean,
background: Color3,
surface: Color3,
raised: Color3,
line: Color3,
lineStrong: Color3,
strong: Color3,
text: Color3,
dim: Color3,
accent: Color3,
warn: Color3,
error: Color3,
}
local FONT = "rbxasset://fonts/families/BuilderSans.json"
local MAX_WIDTH = 460
local HEADER_HEIGHT = 56
local FOOTER_HEIGHT = 26
local PAD = 12
local COLUMN_TOP = 12
local COLUMN_BOTTOM = 20
local LOGO = 32
local ICON_SIZE = 14
local ICON_GAP = 8
local WHITE = Color3.new(1, 1, 1)
local BLACK = Color3.new(0, 0, 0)
local QUICK = TweenInfo.new(0.12, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
local EASE = TweenInfo.new(0.28, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
local GLOW = TweenInfo.new(0.42, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
local SPRING = TweenInfo.new(0.32, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
local PRESS = TweenInfo.new(0.09, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
local NUDGE = TweenInfo.new(0.42, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
local SWEEP = TweenInfo.new(0.85, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
local POP = TweenInfo.new(0.4, Enum.EasingStyle.Back, Enum.EasingDirection.Out)
local PULSE = TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
local GLIDE = TweenInfo.new(0.4, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
local INSTANT = TweenInfo.new(0)
local REVEAL = 0.32
local STAGGER = 0.05
local SLIDE = 8
local RISE = 10
local SINK = 6
local LEAVE = 0.16
local WINDOW_FADE = 0.4
local SPIN = 0.9
local LIFT = 2
local PRESSED = 0.965
local GLOW_REST: { [string]: any } = { Offset = UDim2.fromOffset(0, 10), BlurRadius = UDim.new(0, 28), Transparency = 0.3 }
local GLOW_HOVER: { [string]: any } = { Offset = UDim2.fromOffset(0, 16), BlurRadius = UDim.new(0, 40), Transparency = 0.1 }
local PAGE_PARTS: { [string]: string } = { main = "Main", settings = "Settings", help = "Help" }
local function readColors(): Colors
local site = PALETTE.site
return {
dark = true,
background = site.background,
surface = site.surface,
raised = site.raised,
line = site.line,
lineStrong = site.lineStrong,
strong = site.strong,
text = site.text,
dim = site.dim,
accent = PALETTE.pink,
warn = site.warn,
error = site.error,
}
end
type FadeEntry = { value: number, owner: {} }
type FadeTarget = { object: Instance, name: string, built: number }
type FadeOptions = {
delay: number?,
slide: boolean?,
time: number?,
since: number?,
shallow: boolean?,
}
export type Ui = typeof(setmetatable(
{} :: {
root: Frame,
handlers: Handlers,
info: Info,
colors: Colors,
state: State,
settingsState: SettingsState?,
notices: { Notice },
page: string,
actions: { [GuiObject]: () -> () },
looks: { [GuiObject]: (state: string) -> () },
connections: { RBXScriptConnection },
parts: { [string]: GuiObject },
loops: { [string]: Tween },
resting: { [Instance]: { [string]: FadeEntry } },
leaving: { [GuiObject]: {} },
progressShown: number,
spinAngle: number,
segmentsShown: { boolean },
noticeIds: { string },
revealedAt: number,
still: boolean,
awake: boolean,
pop: boolean,
pasteLook: (() -> ())?,
destroyed: boolean,
},
Ui
))
local function font(weight: Enum.FontWeight): Font
return Font.new(FONT, weight, Enum.FontStyle.Normal)
end
local function textWidth(text: string, size: number): number
local ok, bounds = pcall(function()
return TextService:GetTextSize(text, size, Enum.Font.BuilderSansBold, Vector2.new(10000, 1000))
end)
return if ok then math.ceil(bounds.X) else math.ceil(#text * size * 0.6)
end
local function corner(parent: Instance, radius: number)
local item = Instance.new("UICorner")
item.CornerRadius = if radius < 0 then UDim.new(0.5, 0) else UDim.new(0, radius)
item.Parent = parent
end
local function stroke(parent: Instance, color: Color3, thickness: number?, transparency: number?): UIStroke
local item = Instance.new("UIStroke")
item.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
item.Color = color
item.Thickness = thickness or 1
item.Transparency = transparency or 0
item.Parent = parent
return item
end
local function inside(edge: UIStroke): UIStroke
pcall(function()
edge.BorderStrokePosition = Enum.BorderStrokePosition.Inner
end)
return edge
end
local SHADOW_CLASS: string = "UIShadow"
local function softShadow(parent: Instance, color: Color3, transparency: number, blur: number, offsetY: number?, spread: number?, zIndex: number?): any
local made, created = pcall(Instance.new, SHADOW_CLASS)
if not made then
return nil
end
local shadow: any = created
local ok = pcall(function()
shadow.Color = color
shadow.Transparency = transparency
shadow.BlurRadius = UDim.new(0, blur)
shadow.Offset = UDim2.fromOffset(0, offsetY or 0)
end)
if not ok then
return nil
end
if spread and spread ~= 0 then
pcall(function()
shadow.Spread = UDim2.fromOffset(spread, spread)
end)
end
if zIndex then
pcall(function()
shadow.ZIndex = zIndex
end)
end
shadow.Parent = parent
return shadow
end
local function litFromAbove(edge: UIStroke, top: number, bottom: number)
local light = Instance.new("UIGradient")
light.Rotation = 90
light.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, top),
NumberSequenceKeypoint.new(0.4, (top + bottom) / 2),
NumberSequenceKeypoint.new(1, bottom),
})
light.Parent = edge
end
local function padding(parent: Instance, top: number, right: number, bottom: number, left: number)
local item = Instance.new("UIPadding")
item.PaddingTop = UDim.new(0, top)
item.PaddingRight = UDim.new(0, right)
item.PaddingBottom = UDim.new(0, bottom)
item.PaddingLeft = UDim.new(0, left)
item.Parent = parent
end
local function list(parent: Instance, gap: number, horizontal: boolean?): UIListLayout
local item = Instance.new("UIListLayout")
item.SortOrder = Enum.SortOrder.LayoutOrder
item.Padding = UDim.new(0, gap)
item.FillDirection = if horizontal then Enum.FillDirection.Horizontal else Enum.FillDirection.Vertical
item.Parent = parent
return item
end
local function blank(name: string, order: number?): Frame
local frame = Instance.new("Frame")
frame.Name = name
frame.BackgroundTransparency = 1
frame.BorderSizePixel = 0
frame.LayoutOrder = order or 0
return frame
end
local function stack(parent: Instance, name: string, order: number, gap: number): Frame
local frame = blank(name, order)
frame.Size = UDim2.new(1, 0, 0, 0)
frame.AutomaticSize = Enum.AutomaticSize.Y
list(frame, gap)
frame.Parent = parent
return frame
end
local function flow(parent: Instance, name: string, order: number, gap: number): Frame
local frame = blank(name, order)
frame.Size = UDim2.new(1, 0, 0, 0)
frame.AutomaticSize = Enum.AutomaticSize.Y
local layout = list(frame, gap, true)
layout.Wraps = true
layout.HorizontalFlex = Enum.UIFlexAlignment.Fill
layout.VerticalAlignment = Enum.VerticalAlignment.Center
frame.Parent = parent
return frame
end
local function label(parent: Instance, name: string, text: string, size: number, color: Color3, weight: Enum.FontWeight, order: number): TextLabel
local item = Instance.new("TextLabel")
item.Name = name
item.BackgroundTransparency = 1
item.BorderSizePixel = 0
item.Size = UDim2.new(1, 0, 0, 0)
item.AutomaticSize = Enum.AutomaticSize.Y
item.TextWrapped = true
item.TextXAlignment = Enum.TextXAlignment.Left
item.TextYAlignment = Enum.TextYAlignment.Top
item.FontFace = font(weight)
item.TextSize = size
item.LineHeight = if size <= 14 then 1.12 else 1.05
item.TextColor3 = color
item.Text = text
item.LayoutOrder = order
item.Parent = parent
return item
end
local function badge(parent: Instance, name: string, text: string, color: Color3, size: number, order: number): (Frame, Frame)
local holder = blank(name, order)
holder.Size = UDim2.fromOffset(size, size)
local circle = Instance.new("Frame")
circle.Name = "Circle"
circle.BackgroundColor3 = color
circle.BackgroundTransparency = 0.86
circle.BorderSizePixel = 0
circle.Size = UDim2.fromScale(1, 1)
corner(circle, -1)
local glyph = Instance.new("TextLabel")
glyph.Name = "Glyph"
glyph.BackgroundTransparency = 1
glyph.Size = UDim2.fromScale(1, 1)
glyph.FontFace = font(Enum.FontWeight.Bold)
glyph.TextSize = math.floor(size * 0.6 + 0.5)
glyph.TextColor3 = color
glyph.Text = text
glyph.Parent = circle
circle.Parent = holder
holder.Parent = parent
return holder, circle
end
local function spinner(parent: Instance, color: Color3, size: number, order: number): (Frame, Frame)
local holder = blank("Spinner", order)
holder.Size = UDim2.fromOffset(size, size)
local ring = blank("Ring")
ring.AnchorPoint = Vector2.new(0.5, 0.5)
ring.Position = UDim2.fromScale(0.5, 0.5)
ring.Size = UDim2.fromOffset(size - 8, size - 8)
corner(ring, -1)
local edge = stroke(ring, color, 2.5)
local tail = Instance.new("UIGradient")
tail.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 0),
NumberSequenceKeypoint.new(0.5, 0.1),
NumberSequenceKeypoint.new(1, 1),
})
tail.Parent = edge
ring.Parent = holder
holder.Parent = parent
return holder, ring
end
local function brandGradient(parent: Instance, rotation: number): UIGradient
local item = Instance.new("UIGradient")
item.Color = ColorSequence.new({
ColorSequenceKeypoint.new(0, PALETTE.cyan),
ColorSequenceKeypoint.new(0.5, PALETTE.violet),
ColorSequenceKeypoint.new(1, PALETTE.pink),
})
item.Rotation = rotation
item.Parent = parent
return item
end
local GRID_REACH = Vector2.new(300, 420)
local function gridLines(parent: Instance, strength: number, cell: number)
local wide = math.floor(GRID_REACH.X * 0.75)
local deep = math.floor(GRID_REACH.Y * 0.75)
local holder = blank("Grid")
holder.AnchorPoint = Vector2.new(0.5, 0)
holder.Position = UDim2.fromScale(0.5, 0)
holder.Size = UDim2.fromOffset(2 * wide, deep)
local function mask(x: number, y: number): number
local reach = math.sqrt((x / GRID_REACH.X) ^ 2 + (y / GRID_REACH.Y) ^ 2)
return math.clamp((0.75 - reach) / 0.45, 0, 1)
end
local function line(name: string, position: UDim2, size: UDim2, rotation: number, along: (number) -> number)
local keys = {}
local most = 0
for step = 0, 10 do
local shows = along(step / 10)
most = math.max(most, shows)
table.insert(keys, NumberSequenceKeypoint.new(step / 10, 1 - shows))
end
if most < 0.05 then
return
end
local item = Instance.new("Frame")
item.Name = name
item.BackgroundColor3 = WHITE
item.BackgroundTransparency = 1 - strength
item.BorderSizePixel = 0
item.Position = position
item.Size = size
local fade = Instance.new("UIGradient")
fade.Rotation = rotation
fade.Transparency = NumberSequence.new(keys)
fade.Parent = item
item.Parent = holder
end
local x = cell // 2
while x < wide do
for _, side in { -1, 1 } do
local from = side * x
line("GridColumn", UDim2.fromOffset(wide + from, 0), UDim2.fromOffset(1, deep), 90, function(t: number): number
return mask(from, t * deep)
end)
end
x += cell
end
local y = HEADER_HEIGHT - 1 + cell
while y < deep do
local at = y
line("GridRow", UDim2.fromOffset(0, at), UDim2.fromOffset(2 * wide, 1), 0, function(t: number): number
return mask((t - 0.5) * 2 * wide, at)
end)
y += cell
end
holder.Parent = parent
end
local function clipboard(parent: Instance, color: Color3): Frame
local holder = blank("Icon")
holder.Size = UDim2.fromOffset(20, 24)
local board = blank("Board")
board.Position = UDim2.fromOffset(1, 3)
board.Size = UDim2.fromOffset(18, 21)
corner(board, 4)
stroke(board, color, 1.5)
board.Parent = holder
local clip = Instance.new("Frame")
clip.Name = "Clip"
clip.Position = UDim2.fromOffset(5, 0)
clip.Size = UDim2.fromOffset(10, 5)
clip.BackgroundColor3 = color
clip.BorderSizePixel = 0
clip.ZIndex = 2
corner(clip, 2)
clip.Parent = holder
for index, y in { 11, 16 } do
local line = Instance.new("Frame")
line.Name = "Line" .. index
line.Position = UDim2.fromOffset(6, y)
line.Size = UDim2.fromOffset(if index == 1 then 8 else 5, 2)
line.BackgroundColor3 = color
line.BackgroundTransparency = 0.35
line.BorderSizePixel = 0
corner(line, 1)
line.Parent = holder
end
holder.Parent = parent
return holder
end
local function gear(parent: Instance, color: Color3)
local holder = blank("Icon")
holder.AnchorPoint = Vector2.new(0.5, 0.5)
holder.Position = UDim2.fromScale(0.5, 0.5)
holder.Size = UDim2.fromOffset(16, 16)
local ring = blank("Ring")
ring.AnchorPoint = Vector2.new(0.5, 0.5)
ring.Position = UDim2.fromScale(0.5, 0.5)
ring.Size = UDim2.fromOffset(8, 8)
corner(ring, -1)
stroke(ring, color, 2)
ring.Parent = holder
for index = 0, 7 do
local angle = math.rad(index * 45)
local tooth = Instance.new("Frame")
tooth.Name = "Tooth"
tooth.AnchorPoint = Vector2.new(0.5, 0.5)
tooth.Position = UDim2.new(0.5, math.cos(angle) * 6, 0.5, math.sin(angle) * 6)
tooth.Size = UDim2.fromOffset(4, 3)
tooth.Rotation = index * 45
tooth.BackgroundColor3 = color
tooth.BorderSizePixel = 0
corner(tooth, 1)
tooth.Parent = holder
end
holder.Parent = parent
end
local function key(parent: Instance, text: string, colors: Colors, order: number): TextLabel
local item = Instance.new("TextLabel")
item.Name = "Key"
item.AutomaticSize = Enum.AutomaticSize.X
item.Size = UDim2.fromOffset(0, 20)
item.BackgroundColor3 = colors.raised
item.BorderSizePixel = 0
item.FontFace = font(Enum.FontWeight.SemiBold)
item.TextSize = 12
item.TextColor3 = colors.text
item.Text = text
item.LayoutOrder = order
padding(item, 0, 6, 0, 6)
corner(item, 5)
stroke(item, colors.lineStrong)
item.Parent = parent
return item
end
local function keys(parent: Instance, names: { string }, colors: Colors, order: number): Frame
local row = blank("Keys", order)
row.AutomaticSize = Enum.AutomaticSize.XY
row.Size = UDim2.new()
local layout = list(row, 4, true)
layout.VerticalAlignment = Enum.VerticalAlignment.Center
for index, name in names do
if index > 1 then
local plus = Instance.new("TextLabel")
plus.Name = "Plus"
plus.BackgroundTransparency = 1
plus.AutomaticSize = Enum.AutomaticSize.X
plus.Size = UDim2.fromOffset(0, 20)
plus.FontFace = font(Enum.FontWeight.Medium)
plus.TextSize = 12
plus.TextColor3 = colors.dim
plus.Text = "+"
plus.LayoutOrder = index * 2 - 1
plus.Parent = row
end
key(row, name, colors, index * 2)
end
row.Parent = parent
return row
end
local function shown(item: Instance, root: Instance, leaving: { [GuiObject]: {} }): boolean
local current: Instance? = item
while current and current ~= root do
if current:IsA("GuiObject") and (not current.Visible or leaving[current] ~= nil) then
return false
end
current = current.Parent
end
return current == root
end
local function interactable(item: GuiObject, on: boolean)
pcall(function()
item.Interactable = on
end)
end
local FADE_TEXT = { "BackgroundTransparency", "TextTransparency" }
local FADE_IMAGE = { "BackgroundTransparency", "ImageTransparency" }
local FADE_SCROLL = { "BackgroundTransparency", "ScrollBarImageTransparency" }
local FADE_BOX = { "BackgroundTransparency" }
local FADE_LINE = { "Transparency" }
local FADE_NONE: { string } = {}
local function fadeProperties(item: Instance): { string }
if item:IsA("TextButton") and item.Text == "" then
return FADE_BOX
elseif item:IsA("TextLabel") or item:IsA("TextButton") or item:IsA("TextBox") then
return FADE_TEXT
elseif item:IsA("ImageLabel") or item:IsA("ImageButton") then
return FADE_IMAGE
elseif item:IsA("ScrollingFrame") then
return FADE_SCROLL
elseif item:IsA("GuiObject") then
return FADE_BOX
elseif item:IsA("UIStroke") or item.ClassName == SHADOW_CLASS then
return FADE_LINE
end
return FADE_NONE
end
local function reducedMotion(info: Info): boolean
local forced = info.reducedMotion
if forced ~= nil then
return forced
end
local still = false
pcall(function()
still = GuiService.ReducedMotionEnabled == true
end)
return still
end
function Ui.new(parent: Instance, handlers: Handlers, info: Info): Ui
local root = Instance.new("Frame")
root.Name = "NKD_Window"
root.Size = UDim2.fromScale(1, 1)
root.BorderSizePixel = 0
root.ClipsDescendants = true
local self = setmetatable({
root = root,
handlers = handlers,
info = info,
colors = readColors(),
state = { view = "home", title = "" } :: State,
settingsState = nil :: SettingsState?,
notices = {} :: { Notice },
page = "main",
actions = {} :: { [GuiObject]: () -> () },
looks = {} :: { [GuiObject]: (state: string) -> () },
connections = {} :: { RBXScriptConnection },
parts = {} :: { [string]: GuiObject },
loops = {} :: { [string]: Tween },
resting = {} :: { [Instance]: { [string]: FadeEntry } },
leaving = {} :: { [GuiObject]: {} },
progressShown = 0,
spinAngle = 0,
segmentsShown = {} :: { boolean },
noticeIds = {} :: { string },
revealedAt = -math.huge,
still = reducedMotion(info),
awake = false,
pop = false,
pasteLook = nil :: (() -> ())?,
destroyed = false,
}, Ui)
self:render()
root.Parent = parent
if parent:IsA("LayerCollector") then
table.insert(
self.connections,
parent:GetPropertyChangedSignal("Enabled"):Connect(function()
self:wake()
end)
)
end
table.insert(
self.connections,
root.AncestryChanged:Connect(function()
self:wake()
end)
)
pcall(function()
table.insert(
self.connections,
root.Destroying:Connect(function()
self:stop()
end)
)
end)
if info.reducedMotion == nil then
pcall(function()
table.insert(
self.connections,
GuiService:GetPropertyChangedSignal("ReducedMotionEnabled"):Connect(function()
self:setStill(reducedMotion(info))
end)
)
end)
end
task.defer(function()
self:wake()
end)
return self
end
function Ui.tween(self: Ui, item: Instance, goal: { [string]: any }, info: TweenInfo?)
if self.still then
self:snap(item, goal)
return
end
TweenService:Create(item, info or QUICK, goal):Play()
end
function Ui.snap(self: Ui, item: Instance, goal: { [string]: any })
TweenService:Create(item, INSTANT, goal):Play()
for name, value in goal do
(item :: any)[name] = value
end
end
function Ui.states(self: Ui, item: GuiButton, look: (state: string) -> ())
local inside, selected, down = false, false, false
local current = "normal"
local function update()
local now = if (inside or selected) and down then "pressed" elseif inside or selected then "hover" else "normal"
if now ~= current then
current = now
look(now)
end
end
item.MouseEnter:Connect(function()
inside = true
update()
end)
item.MouseLeave:Connect(function()
inside = false
down = false
update()
end)
item.SelectionGained:Connect(function()
selected = true
update()
end)
item.SelectionLost:Connect(function()
selected = false
down = false
update()
end)
item.MouseButton1Down:Connect(function()
down = true
update()
end)
item.MouseButton1Up:Connect(function()
down = false
update()
end)
self.looks[item] = function(state: string)
selected = false
inside = state == "hover" or state == "pressed"
down = state == "pressed"
if state == "rest" then
current = "normal"
look("rest")
else
update()
end
end
end
function Ui.react(self: Ui, item: GuiButton, normal: { [string]: any }, hover: { [string]: any }, pressed: { [string]: any }, target: Instance?)
local looks: Instance = target or item
self:states(item, function(state: string)
if state == "rest" then
self:snap(looks, normal)
else
self:tween(looks, if state == "hover" then hover elseif state == "pressed" then pressed else normal)
end
end)
end
function Ui.rest(self: Ui, item: Instance)
for button, look in self.looks do
if button:IsDescendantOf(item) then
look("rest")
end
end
end
function Ui.isOpen(self: Ui): boolean
local host = self.root.Parent
if host == nil or not self.root:IsDescendantOf(game) then
return false
end
if host:IsA("LayerCollector") then
return host.Enabled
end
return true
end
function Ui.wake(self: Ui)
if self.destroyed then
return
end
local open = self:isOpen()
if open == self.awake then
return
end
self.awake = open
if open then
self:openPage(self.page, true)
end
self:motion()
end
function Ui.setStill(self: Ui, still: boolean)
if still == self.still or self.destroyed then
return
end
self.still = still
local ring: GuiObject? = self.parts.SpinnerRing
if still then
self:setLoop("spinner", nil)
elseif ring and ring:IsDescendantOf(self.root) then
self:spin(ring)
end
self:drift()
self:motion()
end
function Ui.spin(self: Ui, ring: GuiObject)
local from = ring.Rotation % 360
ring.Rotation = from
local turn = TweenInfo.new(SPIN, Enum.EasingStyle.Linear, Enum.EasingDirection.In, -1)
self:setLoop("spinner", TweenService:Create(ring, turn, { Rotation = from + 360 }))
end
function Ui.setLoop(self: Ui, key: string, tween: Tween?)
local old = self.loops[key]
if old then
old:Cancel()
end
if tween == nil then
self.loops[key] = nil
return
end
self.loops[key] = tween
if self.awake and not self.destroyed then
tween:Play()
end
end
function Ui.motion(self: Ui)
local playing = self.awake and not self.destroyed
for _, tween in self.loops do
if playing then
tween:Play()
else
tween:Pause()
end
end
end
function Ui.stop(self: Ui)
for key in self.loops do
self:setLoop(key, nil)
end
end
function Ui.drift(self: Ui)
for _, light in BACKDROP.lights do
self:setLoop(light.name, nil)
local blob = self.parts[light.name]
if blob then
blob.Position = light.at
if not self.still and light.drift.Magnitude > 0 and light.seconds > 0 then
local away = light.at + UDim2.fromOffset(light.drift.X, light.drift.Y)
local info = TweenInfo.new(light.seconds, Enum.EasingStyle.Cubic, Enum.EasingDirection.InOut, -1, true)
self:setLoop(light.name, TweenService:Create(blob, info, { Position = away }))
end
end
end
end
function Ui.built(self: Ui, object: Instance, name: string): number
local rest = self.resting[object]
local kept = if rest then rest[name] else nil
return if kept then kept.value else (object :: any)[name]
end
function Ui.tint(self: Ui, icon: Instance, color: Color3)
for _, item in icon:GetDescendants() do
if item:IsA("UIStroke") then
item.Color = color
elseif item:IsA("Frame") and self:built(item, "BackgroundTransparency") < 1 then
item.BackgroundColor3 = color
end
end
end
function Ui.fadeTargets(self: Ui, item: Instance, deep: boolean, owner: {}): { FadeTarget }
local targets: { FadeTarget } = {}
local function visit(object: Instance)
for _, name in fadeProperties(object) do
local built = self:built(object, name)
if built < 1 then
local rest = self.resting[object] or {}
self.resting[object] = rest
rest[name] = { value = built, owner = owner }
table.insert(targets, { object = object, name = name, built = built })
end
end
end
visit(item)
if deep then
for _, object in item:GetDescendants() do
visit(object)
end
end
return targets
end
function Ui.fadeTo(self: Ui, targets: { FadeTarget }, visibility: number, info: TweenInfo?, owner: {}?)
for _, target in targets do
if owner then
local rest = self.resting[target.object]
local kept = if rest then rest[target.name] else nil
if kept == nil or kept.owner ~= owner then
continue
end
end
local value = 1 - (1 - target.built) * visibility
if info == nil or self.still then
self:snap(target.object, { [target.name] = value })
else
TweenService:Create(target.object, info, { [target.name] = value }):Play()
end
end
end
function Ui.restore(self: Ui, owner: {})
for object, rest in self.resting do
if object:IsDescendantOf(self.root) then
for name, kept in rest do
if kept.owner == owner then
self:snap(object, { [name] = kept.value })
end
end
end
end
self:settle(owner)
end
function Ui.settle(self: Ui, owner: {})
for object, rest in self.resting do
for name, kept in rest do
if kept.owner == owner then
rest[name] = nil
end
end
if next(rest) == nil then
self.resting[object] = nil
end
end
end
function Ui.fadeIn(self: Ui, item: GuiObject, options: FadeOptions?)
if self.still or not self.awake then
return
end
local choice: FadeOptions = options or {}
local length = choice.time or REVEAL
local done = math.clamp((choice.since or 0) / length, 0, 1)
if done >= 1 then
return
end
local start = 1 - (1 - done) ^ 5
local owner = {}
local targets = self:fadeTargets(item, choice.shallow ~= true, owner)
self:fadeTo(targets, start)
local pad: UIPadding? = if choice.slide then item:FindFirstChildOfClass("UIPadding") else nil
local top, bottom = UDim.new(), UDim.new()
if pad then
top, bottom = pad.PaddingTop, pad.PaddingBottom
local shift = math.floor(math.max(0, math.min(SLIDE, bottom.Offset)) * (1 - start) + 0.5)
pad.PaddingTop = UDim.new(top.Scale, top.Offset + shift)
pad.PaddingBottom = UDim.new(bottom.Scale, bottom.Offset - shift)
end
local info = TweenInfo.new(length * (1 - done), Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
local function play()
if self.destroyed or not item:IsDescendantOf(self.root) then
self:settle(owner)
return
end
self:fadeTo(targets, 1, info, owner)
if pad then
TweenService:Create(pad, info, { PaddingTop = top, PaddingBottom = bottom }):Play()
end
task.delay(info.Time + 0.05, function()
self:settle(owner)
end)
end
local delay = choice.delay or 0
if delay > 0 then
task.delay(delay, play)
else
play()
end
end
function Ui.prune(self: Ui)
for item in self.actions do
if not item:IsDescendantOf(self.root) then
self.actions[item] = nil
end
end
for item in self.looks do
if not item:IsDescendantOf(self.root) then
self.looks[item] = nil
end
end
for object in self.resting do
if not object:IsDescendantOf(self.root) then
self.resting[object] = nil
end
end
end
export type ButtonOptions = {
enabled: boolean?,
full: boolean?,
muted: boolean?,
height: number?,
icon: string?,
}
function Ui.button(self: Ui, parent: Instance, name: string, text: string, kind: string, order: number, action: () -> (), options: ButtonOptions?): TextButton
local colors = self.colors
local choice: ButtonOptions = options or {}
local primary = kind == "primary"
local muted = primary and choice.muted == true
local enabled = choice.enabled ~= false
local height = choice.height or 36
local radius = math.floor(height * 0.3 + 0.5)
local size = if primary then 15 else 14
local inset = if primary then 16 else 14
local sign = if enabled and not muted then choice.icon else nil
local signRoom = if sign then ICON_GAP + ICON_SIZE else 0
local wide = textWidth(text, size)
local item = Instance.new("TextButton")
item.Name = name
item.AutoButtonColor = false
item.BackgroundTransparency = 1
item.BorderSizePixel = 0
item.Text = ""
item.LayoutOrder = order
if choice.full then
item.Size = UDim2.new(1, 0, 0, height)
else
item.Size = UDim2.fromOffset(wide + 2 * inset + signRoom, height)
local grow = Instance.new("UIFlexItem")
grow.FlexMode = Enum.UIFlexMode.Custom
grow.GrowRatio = if primary then 3 else 1
grow.ShrinkRatio = 1
grow.Parent = item
end
local face = Instance.new("Frame")
face.Name = "Face"
face.AnchorPoint = Vector2.new(0.5, 0.5)
face.Position = UDim2.fromScale(0.5, 0.5)
face.Size = UDim2.fromScale(1, 1)
face.BackgroundColor3 = WHITE
face.BorderSizePixel = 0
corner(face, radius)
local press = Instance.new("UIScale")
press.Name = "Press"
press.Parent = face
local caption = Instance.new("TextLabel")
caption.Name = "Label"
caption.BackgroundTransparency = 1
caption.AnchorPoint = Vector2.new(0.5, 0.5)
caption.ZIndex = 3
caption.FontFace = font(if primary then Enum.FontWeight.Bold else Enum.FontWeight.SemiBold)
caption.TextSize = size
caption.TextWrapped = true
caption.TextColor3 = colors.strong
caption.Text = text
caption.Parent = face
local function place(withSign: boolean)
local room = if withSign then signRoom else 0
caption.Position = UDim2.new(0.5, -room // 2, 0.5, 0)
caption.Size = UDim2.new(1, -2 * (inset - 4) - room, 1, 0)
end
place(sign ~= nil)
local glyph: TextLabel? = nil
if sign then
local holder = blank("Icon")
holder.AnchorPoint = Vector2.new(0, 0.5)
holder.Position = UDim2.new(0.5, wide // 2 - signRoom // 2 + ICON_GAP, 0.5, 0)
holder.Size = UDim2.fromOffset(ICON_SIZE, height)
holder.ZIndex = 3
local mark = Instance.new("TextLabel")
mark.Name = "Glyph"
mark.BackgroundTransparency = 1
mark.Size = UDim2.fromScale(1, 1)
mark.ZIndex = 3
mark.FontFace = font(Enum.FontWeight.Bold)
mark.TextSize = size + 1
mark.Text = sign
mark.Parent = holder
holder.Parent = face
glyph = mark
local need = wide + 2 * inset + signRoom
local function fit()
local width = item.AbsoluteSize.X
local fits = width == 0 or width >= need - 1
holder.Visible = fits
place(fits)
end
item:GetPropertyChangedSignal("AbsoluteSize"):Connect(fit)
fit()
end
local lifted = UDim2.new(0.5, 0, 0.5, -LIFT)
local level = UDim2.fromScale(0.5, 0.5)
local look: ((state: string) -> ())? = nil
if primary and not muted then
local shade = Instance.new("UIGradient")
shade.Color = ColorSequence.new({
ColorSequenceKeypoint.new(0, PALETTE.button[1]),
ColorSequenceKeypoint.new(0.45, PALETTE.button[2]),
ColorSequenceKeypoint.new(1, PALETTE.button[3]),
})
shade.Rotation = 45
shade.Parent = face
local edge = inside(stroke(face, WHITE, 1, 0.2))
litFromAbove(edge, 0.575, 0.85)
local sheen = Instance.new("Frame")
sheen.Name = "Sheen"
sheen.BackgroundColor3 = WHITE
sheen.BorderSizePixel = 0
sheen.Size = UDim2.fromScale(1, 1)
sheen.ZIndex = 1
corner(sheen, radius)
local wash = Instance.new("UIGradient")
wash.Rotation = 90
wash.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 0.84),
NumberSequenceKeypoint.new(0.48, 1),
NumberSequenceKeypoint.new(1, 1),
})
wash.Parent = sheen
sheen.Parent = face
caption.TextColor3 = PALETTE.buttonText
if enabled then
local sweep = Instance.new("Frame")
sweep.Name = "Sweep"
sweep.BackgroundColor3 = WHITE
sweep.BorderSizePixel = 0
sweep.Size = UDim2.fromScale(1, 1)
sweep.ZIndex = 2
sweep.Visible = false
corner(sweep, radius)
local band = Instance.new("UIGradient")
band.Name = "Band"
band.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 1),
NumberSequenceKeypoint.new(0.3, 1),
NumberSequenceKeypoint.new(0.48, 0.72),
NumberSequenceKeypoint.new(0.66, 1),
NumberSequenceKeypoint.new(1, 1),
})
band.Offset = Vector2.new(-1.2, 0)
band.Parent = sweep
sweep.Parent = face
local glow = softShadow(face, PALETTE.pink, GLOW_REST.Transparency, 28, 10, -24, -1)
softShadow(face, BLACK, 0.4, 6, 2, -4, -2)
local sweeping: Tween? = nil
local function stopSweep()
local running = sweeping
sweeping = nil
if running then
running:Cancel()
end
sweep.Visible = false
band.Offset = Vector2.new(-1.2, 0)
end
local function startSweep()
stopSweep()
if self.still then
return
end
local box = face.AbsoluteSize
band.Rotation = if box.X > 0 and box.Y > 0 then math.deg(math.atan(math.tan(math.rad(25)) * box.Y / box.X)) else 5
sweep.Visible = true
local tween = TweenService:Create(band, SWEEP, { Offset = Vector2.new(1.2, 0) })
sweeping = tween
tween.Completed:Connect(function()
if sweeping == tween then
sweeping = nil
sweep.Visible = false
end
end)
tween:Play()
end
local last = "normal"
look = function(state: string)
local before = last
last = if state == "rest" then "normal" else state
if state == "rest" then
stopSweep()
self:snap(face, { Position = level })
self:snap(press, { Scale = 1 })
self:snap(edge, { Transparency = 0.2 })
if glow then
self:snap(glow, GLOW_REST)
end
if glyph then
self:snap(glyph, { Position = UDim2.new() })
end
elseif state == "pressed" then
self:tween(face, { Position = level }, PRESS)
self:tween(press, { Scale = PRESSED }, PRESS)
else
local hover = state == "hover"
self:tween(face, { Position = if hover then lifted else level }, SPRING)
self:tween(press, { Scale = 1 }, SPRING)
self:tween(edge, { Transparency = if hover then 0 else 0.2 }, GLOW)
if glow then
self:tween(glow, if hover then GLOW_HOVER else GLOW_REST, GLOW)
end
if glyph then
self:tween(glyph, { Position = if hover then UDim2.fromOffset(3, 0) else UDim2.new() }, NUDGE)
end
if not hover then
stopSweep()
elseif before == "normal" then
startSweep()
end
end
end
else
face.BackgroundTransparency = 0.6
caption.TextTransparency = 0.4
end
elseif muted then
local idle = 0.85
face.BackgroundColor3 = colors.accent
face.BackgroundTransparency = idle
inside(stroke(face, colors.accent, 1, 0.75))
caption.TextColor3 = colors.accent
if enabled then
look = function(state: string)
if state == "rest" then
self:snap(face, { Position = level, BackgroundTransparency = idle })
self:snap(press, { Scale = 1 })
elseif state == "pressed" then
self:tween(face, { Position = level }, PRESS)
self:tween(face, { BackgroundTransparency = idle - 0.12 }, PRESS)
self:tween(press, { Scale = PRESSED }, PRESS)
else
local hover = state == "hover"
self:tween(face, { Position = if hover then lifted else level }, SPRING)
self:tween(face, { BackgroundTransparency = if hover then idle - 0.06 else idle }, EASE)
self:tween(press, { Scale = 1 }, SPRING)
end
end
else
caption.TextTransparency = 0.4
end
else
local glass = Instance.new("UIGradient")
glass.Color = ColorSequence.new(PALETTE.glass[1], PALETTE.glass[2])
glass.Rotation = 90
glass.Transparency = NumberSequence.new(0, 0.12)
glass.Parent = face
local rest = 0.38
face.BackgroundTransparency = rest
local border = inside(stroke(face, colors.lineStrong, 1, 0))
litFromAbove(border, 0, 0.35)
caption.TextColor3 = colors.strong
if enabled then
local lit = blank("Edge")
lit.Size = UDim2.fromScale(1, 1)
lit.ZIndex = 2
corner(lit, radius)
local edge = inside(stroke(lit, WHITE, 1, 1))
local hues = Instance.new("UIGradient")
hues.Color = ColorSequence.new(PALETTE.cyan, PALETTE.pink)
hues.Transparency = NumberSequence.new(0.3, 0.25)
hues.Rotation = 30
hues.Parent = edge
lit.Parent = face
look = function(state: string)
if state == "rest" then
self:snap(face, { Position = level, BackgroundTransparency = rest })
self:snap(press, { Scale = 1 })
self:snap(border, { Transparency = 0 })
self:snap(edge, { Transparency = 1 })
if glyph then
self:snap(glyph, { Position = UDim2.new() })
end
elseif state == "pressed" then
self:tween(face, { Position = level }, PRESS)
self:tween(press, { Scale = PRESSED }, PRESS)
else
local hover = state == "hover"
self:tween(face, { Position = if hover then lifted else level }, SPRING)
self:tween(press, { Scale = 1 }, SPRING)
self:tween(face, { BackgroundTransparency = if hover then 0.05 else rest }, EASE)
self:tween(border, { Transparency = if hover then 1 else 0 }, EASE)
self:tween(edge, { Transparency = if hover then 0 else 1 }, GLOW)
if glyph then
self:tween(glyph, { Position = if hover then UDim2.fromOffset(3, 0) else UDim2.new() }, NUDGE)
end
end
end
else
caption.TextTransparency = 0.55
border.Transparency = 0.5
end
end
if glyph then
glyph.TextColor3 = caption.TextColor3
end
face.Parent = item
if enabled then
local reactTo = look
if reactTo then
self:states(item, reactTo)
end
item.Activated:Connect(function()
action()
end)
self.actions[item] = action
else
item.Active = false
end
item.Parent = parent
return item
end
function Ui.iconButton(self: Ui, parent: Instance, name: string, order: number, active: boolean, draw: (GuiObject, Color3) -> (), action: () -> ()): TextButton
local colors = self.colors
local item = Instance.new("TextButton")
item.Name = name
item.AutoButtonColor = false
item.BorderSizePixel = 0
item.Text = ""
item.Size = UDim2.fromOffset(30, 30)
item.LayoutOrder = order
item.BackgroundColor3 = if active then colors.accent else colors.raised
local idle = if active then (if colors.dark then 0.84 else 0.88) else 1
item.BackgroundTransparency = idle
corner(item, 8)
draw(item, if active then colors.accent else colors.dim)
self:react(item, { BackgroundTransparency = idle }, { BackgroundTransparency = if active then idle - 0.06 else 0 }, { BackgroundTransparency = if active then idle - 0.12 else 0 })
item.Activated:Connect(action)
self.actions[item] = action
item.Parent = parent
return item
end
function Ui.choice(self: Ui, parent: Instance, name: string, text: string, selected: boolean, order: number, action: () -> ())
local colors = self.colors
local row = Instance.new("TextButton")
row.Name = name
row.AutoButtonColor = false
row.BackgroundColor3 = colors.raised
row.BackgroundTransparency = 1
row.BorderSizePixel = 0
row.Size = UDim2.new(1, 0, 0, 0)
row.AutomaticSize = Enum.AutomaticSize.Y
row.Text = ""
row.LayoutOrder = order
corner(row, 6)
padding(row, 6, 8, 6, 8)
local ring = Instance.new("Frame")
ring.Name = "Ring"
ring.Size = UDim2.fromOffset(16, 16)
ring.Position = UDim2.fromOffset(0, 1)
ring.BackgroundColor3 = colors.background
ring.BorderSizePixel = 0
corner(ring, -1)
stroke(ring, if selected then colors.accent else colors.lineStrong, if selected then 1.5 else 1)
if selected then
local dot = Instance.new("Frame")
dot.Name = "Dot"
dot.Size = UDim2.fromOffset(8, 8)
dot.Position = UDim2.fromScale(0.5, 0.5)
dot.AnchorPoint = Vector2.new(0.5, 0.5)
dot.BackgroundColor3 = colors.accent
dot.BorderSizePixel = 0
corner(dot, -1)
dot.Parent = ring
end
ring.Parent = row
local text_ = label(row, "Label", text, 14, if selected then colors.strong else colors.text, if selected then Enum.FontWeight.Medium else Enum.FontWeight.Regular, 1)
text_.Size = UDim2.new(1, -26, 0, 0)
text_.Position = UDim2.fromOffset(26, 0)
self:react(row, { BackgroundTransparency = 1 }, { BackgroundTransparency = 0.4 }, { BackgroundTransparency = 0 })
row.Activated:Connect(action)
self.actions[row] = action
row.Parent = parent
end
function Ui.card(self: Ui, parent: Instance, name: string, order: number, gap: number?): Frame
local card = stack(parent, name, order, gap or 10)
card.BackgroundTransparency = 0
card.BackgroundColor3 = self.colors.surface
corner(card, 14)
litFromAbove(stroke(card, WHITE), 0.8, 0.93)
softShadow(card, BLACK, 0.5, 22, 8)
padding(card, 14, 14, 14, 14)
return card
end
function Ui.linkBox(self: Ui, parent: Instance, name: string, url: string, order: number): TextBox
local colors = self.colors
local item = Instance.new("TextBox")
item.Name = name
item.Size = UDim2.new(1, 0, 0, 0)
item.AutomaticSize = Enum.AutomaticSize.Y
item.BackgroundColor3 = colors.background
item.BorderSizePixel = 0
item.ClearTextOnFocus = false
item.TextEditable = false
item.TextWrapped = true
item.TextXAlignment = Enum.TextXAlignment.Left
item.FontFace = font(Enum.FontWeight.Medium)
item.TextSize = 13
item.TextColor3 = colors.accent
item.Text = url
item.LayoutOrder = order
corner(item, 8)
local edge = stroke(item, colors.lineStrong)
padding(item, 8, 10, 8, 10)
item.Focused:Connect(function()
edge.Color = colors.accent
task.defer(function()
if item.Parent then
item.SelectionStart = 1
item.CursorPosition = #item.Text + 1
end
end)
end)
item.FocusLost:Connect(function()
edge.Color = colors.lineStrong
end)
item.Parent = parent
return item
end
function Ui.mark(self: Ui, parent: Instance): ImageLabel?
local icon = Brand.toolbarIcon or ""
if icon == "" then
return nil
end
local logo = Instance.new("ImageLabel")
logo.Name = "Logo"
logo.BackgroundTransparency = 1
logo.BorderSizePixel = 0
logo.AnchorPoint = Vector2.new(0.5, 0.5)
logo.Position = UDim2.new(0, LOGO // 2, 0.5, 0)
logo.Size = UDim2.fromOffset(LOGO, LOGO)
logo.ScaleType = Enum.ScaleType.Fit
logo.Image = icon
logo.MouseEnter:Connect(function()
if not self.still then
self:tween(logo, { Rotation = -6, Size = UDim2.fromOffset(LOGO + 2, LOGO + 2) }, EASE)
end
end)
logo.MouseLeave:Connect(function()
self:tween(logo, { Rotation = 0, Size = UDim2.fromOffset(LOGO, LOGO) }, EASE)
end)
logo.Parent = parent
return logo
end
function Ui.render(self: Ui)
if self.destroyed then
return
end
local root = self.root
self:stop()
for _, child in root:GetChildren() do
child:Destroy()
end
table.clear(self.actions)
table.clear(self.looks)
table.clear(self.parts)
table.clear(self.resting)
table.clear(self.leaving)
root.BackgroundColor3 = self.colors.background
self:renderBackdrop()
local body = blank("Body")
body.Position = UDim2.fromOffset(0, HEADER_HEIGHT)
body.Size = UDim2.new(1, 0, 1, -HEADER_HEIGHT - FOOTER_HEIGHT)
body.Parent = root
self:makePage(body, "Main")
self:makePage(body, "Settings")
self:makePage(body, "Help")
self:renderNotices()
self:renderPaste()
self:renderCard()
self:renderMore()
self:renderSettings()
self:renderHelp()
self:renderFooter()
self:showPage(self.page)
end
function Ui.renderBackdrop(self: Ui)
local backdrop = blank("Backdrop")
backdrop.Size = UDim2.fromScale(1, 1)
backdrop.ZIndex = 0
for _, light in BACKDROP.lights do
local blob = blank(light.name)
blob.AnchorPoint = Vector2.new(0.5, 0.5)
blob.Position = light.at
blob.Size = UDim2.fromOffset(light.size.X, light.size.Y)
corner(blob, -1)
for index, glow in light.glows do
softShadow(blob, glow.color, glow.transparency, glow.blur, 0, glow.spread, index - #light.glows - 1)
end
blob.Parent = backdrop
self.parts[light.name] = blob
end
if BACKDROP.grid > 0 then
gridLines(backdrop, BACKDROP.grid, BACKDROP.cell)
end
backdrop.Parent = self.root
self.parts.Backdrop = backdrop
self:drift()
end
function Ui.renderFooter(self: Ui)
local info = self.info
local footer = blank("Footer")
footer.AnchorPoint = Vector2.new(0, 1)
footer.Position = UDim2.fromScale(0, 1)
footer.Size = UDim2.new(1, 0, 0, FOOTER_HEIGHT)
local words = info.pluginName .. " v" .. (info.version or Brand.pluginVersion) .. " · " .. (info.copyright or Brand.copyright)
local text = label(footer, "Text", words, 11, self.colors.dim, Enum.FontWeight.Regular, 1)
text.AnchorPoint = Vector2.new(0.5, 0.5)
text.Position = UDim2.fromScale(0.5, 0.5)
text.Size = UDim2.new(1, -2 * PAD, 0, 0)
text.TextXAlignment = Enum.TextXAlignment.Center
text.TextWrapped = false
text.TextTruncate = Enum.TextTruncate.AtEnd
footer.Parent = self.root
self.parts.Footer = text
end
function Ui.noticeSteps(self: Ui, parent: Instance, steps: { string }, link: string?, order: number)
local colors = self.colors
local holder = stack(parent, "Steps", order, 8)
for index, step in steps do
local row = stack(holder, "Step" .. index, index, 6)
local line = blank("Line", 1)
line.Size = UDim2.new(1, 0, 0, 0)
line.AutomaticSize = Enum.AutomaticSize.Y
badge(line, "Number", tostring(index), colors.text, 20, 1)
local text = label(line, "Text", step, 13, colors.text, Enum.FontWeight.Regular, 2)
text.Position = UDim2.fromOffset(30, 1)
text.Size = UDim2.new(1, -30, 0, 0)
line.Parent = row
if index == 1 and link then
local indent = blank("LinkRow", 2)
indent.Size = UDim2.new(1, 0, 0, 0)
indent.AutomaticSize = Enum.AutomaticSize.Y
padding(indent, 0, 0, 0, 30)
self:linkBox(indent, "Link", link, 1)
indent.Parent = row
end
end
end
function Ui.renderNotices(self: Ui)
local old: GuiObject? = self.parts.Notices
if old then
old:Destroy()
end
local column: GuiObject? = self.parts.MainColumn
if column == nil then
return
end
local colors = self.colors
local holder = stack(column, "Notices", 0, 8)
holder.Visible = #self.notices > 0
self.parts.Notices = holder
local before = self.noticeIds
local ids: { string } = {}
for index, notice in self.notices do
local warn = notice.tone == "warn"
local box = stack(holder, "Notice" .. index, index, 6)
box.BackgroundTransparency = if warn then (if colors.dark then 0.9 else 0.88) else 0
box.BackgroundColor3 = if warn then colors.warn else colors.surface
corner(box, 12)
if warn then
stroke(box, colors.warn, 1, 0.7)
else
litFromAbove(stroke(box, WHITE), 0.8, 0.93)
end
padding(box, 10, 10, 12, 12)
local head = blank("Head", 1)
head.Size = UDim2.new(1, 0, 0, 0)
head.AutomaticSize = Enum.AutomaticSize.Y
badge(head, "Icon", if warn then "!" else "↑", if warn then colors.warn else colors.text, 20, 1)
local title = label(head, "Title", notice.title, 13, colors.strong, Enum.FontWeight.Bold, 2)
title.Position = UDim2.fromOffset(28, 2)
local id = notice.id
local buttons = notice.actions
local own = buttons ~= nil and #buttons > 0
title.Size = UDim2.new(1, if own then -28 else -56, 0, 0)
if not own then
local hide = Instance.new("TextButton")
hide.Name = "HideNotice"
hide.AutoButtonColor = false
hide.AnchorPoint = Vector2.new(1, 0)
hide.Position = UDim2.fromScale(1, 0)
hide.Size = UDim2.fromOffset(22, 22)
hide.BackgroundColor3 = colors.raised
hide.BackgroundTransparency = 1
hide.BorderSizePixel = 0
hide.FontFace = font(Enum.FontWeight.Bold)
hide.TextSize = 16
hide.TextColor3 = colors.dim
hide.Text = "×"
corner(hide, 6)
self:react(hide, { BackgroundTransparency = 1 }, { BackgroundTransparency = 0 }, { BackgroundTransparency = 0 })
local function action()
self.handlers.hideNotice(id)
end
hide.Activated:Connect(action)
self.actions[hide] = action
hide.Parent = head
end
head.Parent = box
label(box, "Text", notice.text, 13, colors.text, Enum.FontWeight.Regular, 2)
local link = notice.link
local steps = notice.steps
if steps and #steps > 0 then
self:noticeSteps(box, steps, link, 3)
elseif link then
self:linkBox(box, "Link", link, 3)
end
if buttons and own then
local row = flow(box, "Buttons", 4, 6)
for index, button in buttons do
local actionId = button.id
self:button(row, actionId, button.label, if button.primary then "primary" else "secondary", index, function()
local handler = self.handlers.noticeAction
if handler then
handler(id, actionId)
end
end, { height = 28 })
end
end
table.insert(ids, id)
if not table.find(before, id) and self.page == "main" then
self:fadeIn(box, { delay = (#ids - 1) * STAGGER, slide = true })
end
end
self.noticeIds = ids
end
function Ui.makePage(self: Ui, parent: Instance, name: string)
local scroll = Instance.new("ScrollingFrame")
scroll.Name = name .. "Page"
scroll.Size = UDim2.fromScale(1, 1)
scroll.BackgroundTransparency = 1
scroll.BorderSizePixel = 0
scroll.CanvasSize = UDim2.new()
scroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
scroll.ScrollingDirection = Enum.ScrollingDirection.Y
scroll.ScrollBarThickness = 4
scroll.ScrollBarImageColor3 = self.colors.dim
scroll.ScrollBarImageTransparency = 0.4
scroll.VerticalScrollBarInset = Enum.ScrollBarInset.ScrollBar
scroll.Visible = false
local layout = list(scroll, 0)
layout.HorizontalAlignment = Enum.HorizontalAlignment.Center
local column = blank(name, 1)
column.Size = UDim2.new(1, 0, 0, 0)
column.AutomaticSize = Enum.AutomaticSize.Y
local limit = Instance.new("UISizeConstraint")
limit.MaxSize = Vector2.new(MAX_WIDTH, math.huge)
limit.Parent = column
padding(column, COLUMN_TOP, PAD, COLUMN_BOTTOM, PAD)
list(column, 12)
column.Parent = scroll
scroll.Parent = parent
self.parts[name .. "Column"] = column
self.parts[name .. "Page"] = scroll
end
function Ui.openPage(self: Ui, page: string, window: boolean?)
local prefix = PAGE_PARTS[page]
if prefix == nil or self.still or not self.awake then
return
end
local scroll: GuiObject? = self.parts[prefix .. "Page"]
local column: GuiObject? = self.parts[prefix .. "Column"]
if scroll == nil or column == nil then
return
end
self:rest(if window then self.root else scroll)
local holder: Instance = column:FindFirstChild("Body") or column
local sections: { GuiObject } = {}
for _, child in holder:GetChildren() do
if child:IsA("GuiObject") and child.Visible then
table.insert(sections, child)
end
end
table.sort(sections, function(a: GuiObject, b: GuiObject): boolean
return a.LayoutOrder < b.LayoutOrder
end)
for index, section in sections do
self:fadeIn(section, { delay = (index - 1) * STAGGER })
end
self:fadeIn(scroll, { shallow = true })
local pad = column:FindFirstChildOfClass("UIPadding")
if pad then
pad.PaddingTop = UDim.new(0, COLUMN_TOP + RISE)
pad.PaddingBottom = UDim.new(0, COLUMN_BOTTOM - RISE)
local rise = TweenInfo.new(REVEAL + STAGGER, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
TweenService:Create(pad, rise, { PaddingTop = UDim.new(0, COLUMN_TOP), PaddingBottom = UDim.new(0, COLUMN_BOTTOM) }):Play()
end
if window then
local header, footer, backdrop = self.parts.Header, self.parts.Footer, self.parts.Backdrop
if header then
self:fadeIn(header)
end
if footer then
self:fadeIn(footer, { delay = 2 * STAGGER })
end
if backdrop then
self:fadeIn(backdrop, { time = WINDOW_FADE })
end
end
end
function Ui.leavePage(self: Ui, page: string)
local prefix = PAGE_PARTS[page]
local found: GuiObject? = if prefix then self.parts[prefix .. "Page"] else nil
if found == nil then
return
end
local scroll: GuiObject = found
if self.still or not self.awake or not scroll.Visible then
scroll.Visible = false
return
end
self:rest(scroll)
local owner = {}
self.leaving[scroll] = owner
scroll.ZIndex = 0
interactable(scroll, false)
local targets = self:fadeTargets(scroll, true, owner)
local info = TweenInfo.new(LEAVE, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
self:fadeTo(targets, 0, info, owner)
local column: GuiObject? = self.parts[prefix .. "Column"]
local pad: UIPadding? = if column then column:FindFirstChildOfClass("UIPadding") else nil
if pad then
TweenService:Create(pad, info, { PaddingTop = UDim.new(0, COLUMN_TOP - SINK), PaddingBottom = UDim.new(0, COLUMN_BOTTOM + SINK) }):Play()
end
task.delay(LEAVE + 0.02, function()
if self.leaving[scroll] ~= owner then
return
end
self.leaving[scroll] = nil
scroll.Visible = false
scroll.ZIndex = 1
interactable(scroll, true)
self:restore(owner)
if pad then
self:snap(pad, { PaddingTop = UDim.new(0, COLUMN_TOP), PaddingBottom = UDim.new(0, COLUMN_BOTTOM) })
end
end)
end
function Ui.followLeave(self: Ui, page: string, first: GuiObject?, second: GuiObject?)
local prefix = PAGE_PARTS[page]
local scroll: GuiObject? = if prefix then self.parts[prefix .. "Page"] else nil
local owner = if scroll then self.leaving[scroll] else nil
if owner == nil then
return
end
if first then
self:fadeTo(self:fadeTargets(first, true, owner), 0)
end
if second then
self:fadeTo(self:fadeTargets(second, true, owner), 0)
end
end
function Ui.showPage(self: Ui, page: string)
local previous = self.page
self.page = page
for name, prefix in PAGE_PARTS do
local scroll = self.parts[prefix .. "Page"]
if scroll then
if name == page then
self.leaving[scroll] = nil
scroll.ZIndex = 1
interactable(scroll, true)
scroll.Visible = true
elseif name == previous and previous ~= page then
self:leavePage(name)
elseif self.leaving[scroll] == nil then
scroll.Visible = false
end
end
end
self:renderHeader()
if previous ~= page then
self:openPage(page)
end
end
function Ui.renderHeader(self: Ui)
local old = self.parts.Header
if old then
old:Destroy()
self:prune()
end
local colors = self.colors
local header = Instance.new("Frame")
header.Name = "Header"
header.BackgroundColor3 = colors.background
header.BackgroundTransparency = 1
header.BorderSizePixel = 0
header.Size = UDim2.new(1, 0, 0, HEADER_HEIGHT)
local inner = blank("Inner")
inner.AnchorPoint = Vector2.new(0.5, 0)
inner.Position = UDim2.fromScale(0.5, 0)
inner.Size = UDim2.new(1, -2 * PAD, 1, -1)
local limit = Instance.new("UISizeConstraint")
limit.MaxSize = Vector2.new(MAX_WIDTH - 2 * PAD, math.huge)
limit.Parent = inner
inner.Parent = header
local logo = self:mark(inner)
local left = if logo then LOGO + 10 else 0
local names = blank("Names")
names.AnchorPoint = Vector2.new(0, 0.5)
names.Position = UDim2.new(0, left, 0.5, 0)
names.Size = UDim2.new(1, -left - 72, 0, 0)
names.AutomaticSize = Enum.AutomaticSize.Y
list(names, 0)
local title = label(names, "Title", self.info.pluginName, 16, colors.strong, Enum.FontWeight.Bold, 1)
title.TextWrapped = false
title.TextTruncate = Enum.TextTruncate.AtEnd
local subtitle = label(names, "Subtitle", "for " .. self.info.toolName, 12, colors.dim, Enum.FontWeight.Medium, 2)
subtitle.TextWrapped = false
subtitle.TextTruncate = Enum.TextTruncate.AtEnd
names.Parent = inner
local buttons = blank("Buttons")
buttons.AnchorPoint = Vector2.new(1, 0.5)
buttons.Position = UDim2.fromScale(1, 0.5)
buttons.Size = UDim2.fromOffset(66, 30)
local layout = list(buttons, 6, true)
layout.HorizontalAlignment = Enum.HorizontalAlignment.Right
self:iconButton(buttons, "HelpToggle", 1, self.page == "help", function(holder: GuiObject, color: Color3)
local glyph = Instance.new("TextLabel")
glyph.Name = "Icon"
glyph.BackgroundTransparency = 1
glyph.Size = UDim2.fromScale(1, 1)
glyph.FontFace = font(Enum.FontWeight.Bold)
glyph.TextSize = 16
glyph.TextColor3 = color
glyph.Text = "?"
glyph.Parent = holder
end, function()
self:showPage(if self.page == "help" then "main" else "help")
end)
self:iconButton(buttons, "SettingsToggle", 2, self.page == "settings", gear, function()
self:showPage(if self.page == "settings" then "main" else "settings")
end)
buttons.Parent = inner
local divider = Instance.new("Frame")
divider.Name = "Divider"
divider.AnchorPoint = Vector2.new(0, 1)
divider.Position = UDim2.fromScale(0, 1)
divider.Size = UDim2.new(1, 0, 0, 1)
divider.BackgroundColor3 = WHITE
divider.BorderSizePixel = 0
local fade = brandGradient(divider, 0)
fade.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 1),
NumberSequenceKeypoint.new(0.3, 0.62),
NumberSequenceKeypoint.new(0.7, 0.62),
NumberSequenceKeypoint.new(1, 1),
})
divider.Parent = header
header.Parent = self.root
self.parts.Header = header
end
function Ui.renderPaste(self: Ui)
local old = self.parts.Paste
if old then
old:Destroy()
end
local colors = self.colors
local busy = self.state.busy == true
local holder = stack(self.parts.MainColumn, "Paste", 1, 8)
self.parts.Paste = holder
local area = Instance.new("Frame")
area.Name = "PasteArea"
area.Size = UDim2.new(1, 0, 0, 128)
area.BackgroundColor3 = if busy then colors.background else colors.surface
area.BorderSizePixel = 0
area.LayoutOrder = 1
corner(area, 14)
local edge = stroke(area, colors.lineStrong, 1.5)
litFromAbove(edge, 0, 0.4)
softShadow(area, BLACK, 0.5, 22, 8)
self.parts.PasteArea = area
local icon = clipboard(area, colors.dim)
icon.AnchorPoint = Vector2.new(0.5, 0)
icon.Position = UDim2.new(0.5, 0, 0, 18)
local hint = keys(area, { "Ctrl", "V" }, colors, 0)
hint.AnchorPoint = Vector2.new(0.5, 1)
hint.Position = UDim2.new(0.5, 0, 1, -14)
hint.Visible = not busy
local box = Instance.new("TextBox")
box.Name = "PasteBox"
box.Size = UDim2.fromScale(1, 1)
box.BackgroundTransparency = 1
box.BorderSizePixel = 0
box.ZIndex = 3
box.ClearTextOnFocus = true
box.MultiLine = true
box.TextWrapped = true
box.TextTruncate = Enum.TextTruncate.AtEnd
box.ClipsDescendants = true
box.TextXAlignment = Enum.TextXAlignment.Center
box.TextYAlignment = Enum.TextYAlignment.Center
box.FontFace = font(Enum.FontWeight.SemiBold)
box.TextSize = 15
box.TextColor3 = colors.strong
box.PlaceholderColor3 = if busy then colors.dim else colors.strong
box.PlaceholderText = if busy then "Working… one moment" else "Paste the code from " .. self.info.toolName .. " here"
box.Text = ""
box.TextEditable = not busy
padding(box, 46, 16, 38, 16)
local focused = false
local hovered = false
local function look()
if busy then
return
end
edge.Thickness = if focused then 2 else 1.5
self:tween(edge, { Color = if focused then colors.accent elseif hovered then colors.dim else colors.lineStrong })
local view = self.state.view
self:tint(icon, if focused or view == "home" or view == "pasting" then colors.accent else colors.dim)
end
self.pasteLook = look
look()
box.MouseEnter:Connect(function()
hovered = true
look()
end)
box.MouseLeave:Connect(function()
hovered = false
look()
end)
local clearing = false
local function take()
local text = box.Text
if clearing or text == "" then
return
end
clearing = true
box.Text = ""
clearing = false
task.defer(self.handlers.paste, text)
end
box:GetPropertyChangedSignal("Text"):Connect(function()
local text = box.Text
if not clearing and (hasCode(text) or #text > 100) then
take()
end
end)
box.FocusLost:Connect(function()
focused = false
look()
take()
end)
box.Focused:Connect(function()
focused = true
look()
end)
box.Parent = area
area.Parent = holder
self.parts.PasteBox = box
local how = label(holder, "PasteHint", "In " .. self.info.toolName .. ": Export, then Copy for the Studio plugin.", 12, colors.dim, Enum.FontWeight.Regular, 2)
how.TextXAlignment = Enum.TextXAlignment.Center
end
function Ui.renderMore(self: Ui)
local old = self.parts.More
if old then
old:Destroy()
end
local busy = self.state.busy == true
local row = flow(self.parts.MainColumn, "More", 3, 8)
self.parts.More = row
self.parts.Import = self:button(row, "ImportFile", "Import file (." .. Brand.bundleExtension .. ")", "secondary", 1, self.handlers.importFile, { enabled = not busy, height = 32 })
self.parts.Export = self:button(row, "Export", "Export to designer", "secondary", 2, self.handlers.export, { enabled = not busy, height = 32 })
end
function Ui.focusPaste(self: Ui)
if self.page ~= "main" then
self:showPage("main")
end
local box = self.parts.PasteBox
if box and box:IsDescendantOf(self.root) and box:IsA("TextBox") and box.TextEditable then
box:CaptureFocus()
end
end
function Ui.nudge(self: Ui)
local area: GuiObject? = self.parts.PasteArea
if area == nil or self.still then
return
end
local normal = area.BackgroundColor3
area.BackgroundColor3 = normal:Lerp(self.colors.accent, 0.12)
self:tween(area, { BackgroundColor3 = normal }, TweenInfo.new(0.6, Enum.EasingStyle.Quad, Enum.EasingDirection.Out))
end
function Ui.pasteText(self: Ui, text: string)
local box = self.parts.PasteBox
if box and box:IsA("TextBox") then
box.Text = text
end
end
local CARD_PARTS = { "Card", "Recent", "CardTitle", "CardText", "CardLink", "Progress", "SpinnerRing", "Confirm", "Cancel", "Placeholders", "Dismiss", "Settings", "Help" }
function Ui.renderCard(self: Ui)
local same = not self.pop
local oldFill: GuiObject? = self.parts.Progress
local oldRing: GuiObject? = self.parts.SpinnerRing
self.progressShown = if same and oldFill and oldFill:IsDescendantOf(self.root) then oldFill.Size.X.Scale else 0
self.spinAngle = if same and oldRing and oldRing:IsDescendantOf(self.root) then oldRing.Rotation % 360 else 0
self:setLoop("spinner", nil)
for _, name in CARD_PARTS do
local old = self.parts[name]
if old and (name == "Card" or name == "Recent") then
old:Destroy()
end
self.parts[name] = nil
end
local state = self.state
if state.view == "home" then
self.segmentsShown = {}
self:renderHome()
self:revealCard(self.parts.Card, self.parts.Recent)
return
end
local colors = self.colors
local card = self:card(self.parts.MainColumn, "Card", 2)
self.parts.Card = card
local head = blank("Head", 1)
head.Size = UDim2.new(1, 0, 0, 0)
head.AutomaticSize = Enum.AutomaticSize.Y
local headLayout = list(head, 10, true)
headLayout.VerticalAlignment = Enum.VerticalAlignment.Center
self:stateIcon(head, state)
local title = label(head, "Title", state.title, 15, colors.strong, Enum.FontWeight.Bold, 2)
title.Size = UDim2.new(1, -34, 0, 0)
head.Parent = card
self.parts.CardTitle = title
if state.text and state.text ~= "" then
self.parts.CardText = label(card, "Text", state.text, 14, colors.text, Enum.FontWeight.Regular, 2)
end
local segments = state.segments
if segments and #segments > 0 and #segments <= 16 then
local before = if same then self.segmentsShown else {}
local row = blank("Segments", 3)
row.Size = UDim2.new(1, 0, 0, 6)
local layout = list(row, 4, true)
layout.HorizontalFlex = Enum.UIFlexAlignment.Fill
for index, pasted in segments do
local piece = Instance.new("Frame")
piece.Name = "Part" .. index
piece.Size = UDim2.new(0, 8, 1, 0)
piece.BackgroundColor3 = if pasted then colors.accent else colors.raised
piece.BorderSizePixel = 0
piece.LayoutOrder = index
corner(piece, 3)
piece.Parent = row
if pasted and before[index] == false then
piece.BackgroundColor3 = colors.raised
self:tween(piece, { BackgroundColor3 = colors.accent }, GLOW)
end
end
row.Parent = card
self.segmentsShown = table.clone(segments)
elseif state.progress then
self.segmentsShown = {}
local track = Instance.new("Frame")
track.Name = "Progress"
track.Size = UDim2.new(1, 0, 0, 6)
track.BackgroundColor3 = colors.raised
track.BorderSizePixel = 0
track.LayoutOrder = 3
corner(track, 3)
local fill = Instance.new("Frame")
fill.Name = "Fill"
fill.BackgroundColor3 = WHITE
fill.BorderSizePixel = 0
corner(fill, 3)
local shade = Instance.new("UIGradient")
shade.Color = ColorSequence.new({
ColorSequenceKeypoint.new(0, PALETTE.violet),
ColorSequenceKeypoint.new(0.55, colors.accent),
ColorSequenceKeypoint.new(1, colors.accent),
})
shade.Parent = fill
fill.Size = UDim2.fromScale(self.progressShown, 1)
fill.Parent = track
track.Parent = card
self.parts.Progress = fill
self:tween(fill, { Size = UDim2.fromScale(math.clamp(state.progress, 0, 1), 1) }, GLIDE)
else
self.segmentsShown = {}
end
local lines = state.lines
if lines and #lines > 0 then
local stackOfLines = stack(card, "Lines", 4, 6)
for index, line in lines do
local row = blank("Line" .. index, index)
row.Size = UDim2.new(1, 0, 0, 0)
row.AutomaticSize = Enum.AutomaticSize.Y
local dot = Instance.new("Frame")
dot.Name = "Dot"
dot.Position = UDim2.fromOffset(2, 7)
dot.Size = UDim2.fromOffset(5, 5)
dot.BackgroundColor3 = colors.dim
dot.BorderSizePixel = 0
corner(dot, -1)
dot.Parent = row
local text = label(row, "Text", line, 14, colors.text, Enum.FontWeight.Regular, 1)
text.Position = UDim2.fromOffset(16, 0)
text.Size = UDim2.new(1, -16, 0, 0)
row.Parent = stackOfLines
end
end
local steps = state.steps
if steps and #steps > 0 then
local stackOfSteps = stack(card, "Steps", 5, 8)
for index, step in steps do
local row = blank("Step" .. index, index)
row.Size = UDim2.new(1, 0, 0, 0)
row.AutomaticSize = Enum.AutomaticSize.Y
badge(row, "Number", tostring(index), colors.text, 20, 1)
local text = label(row, "Text", step, 13, colors.text, Enum.FontWeight.Regular, 2)
text.Position = UDim2.fromOffset(30, 1)
text.Size = UDim2.new(1, -30, 0, 0)
row.Parent = stackOfSteps
end
end
local warnings = state.warnings
if warnings and #warnings > 0 then
local box = stack(card, "Warnings", 6, 4)
box.BackgroundTransparency = if colors.dark then 0.9 else 0.88
box.BackgroundColor3 = colors.warn
corner(box, 8)
stroke(box, colors.warn, 1, 0.7)
padding(box, 8, 10, 8, 10)
for index, warning in warnings do
label(box, "Warning" .. index, warning, 13, colors.text, Enum.FontWeight.Regular, index)
end
end
local notes = state.notes
if notes and #notes > 0 then
local stackOfNotes = stack(card, "Notes", 7, 4)
for index, note in notes do
label(stackOfNotes, "Note" .. index, note, 12, colors.dim, Enum.FontWeight.Regular, index)
end
end
if state.undo then
local row = blank("Undo", 8)
row.Size = UDim2.new()
row.AutomaticSize = Enum.AutomaticSize.XY
local layout = list(row, 6, true)
layout.VerticalAlignment = Enum.VerticalAlignment.Center
local words = label(row, "Text", "Undo with", 12, colors.dim, Enum.FontWeight.Medium, 1)
words.AutomaticSize = Enum.AutomaticSize.XY
words.Size = UDim2.new()
words.TextWrapped = false
keys(row, { "Ctrl", "Z" }, colors, 2)
row.Parent = card
end
if state.link then
self.parts.CardLink = self:linkBox(card, "Link", state.link, 9)
end
local actions = state.actions
if actions and #actions > 0 then
local row = flow(card, "Buttons", 10, 8)
local handlerOf: { [string]: () -> () } = {
confirm = self.handlers.confirm,
cancel = self.handlers.cancel,
placeholders = self.handlers.placeholders,
dismiss = self.handlers.dismiss,
settings = function()
self:showPage("settings")
end,
help = function()
self:showPage("help")
end,
}
for index, action in actions do
local handler = handlerOf[action.id]
if handler then
local name = string.upper(string.sub(action.id, 1, 1)) .. string.sub(action.id, 2)
self.parts[name] = self:button(row, name, action.label, if action.primary then "primary" else "secondary", index, handler, {
icon = if action.primary then "→" else nil,
})
end
end
end
self:revealCard(card)
end
function Ui.revealCard(self: Ui, first: GuiObject?, second: GuiObject?)
if self.page ~= "main" then
return
end
local since = 0
if self.pop then
self.revealedAt = os.clock()
else
since = os.clock() - self.revealedAt
if since >= REVEAL then
return
end
end
if first then
self:fadeIn(first, { slide = true, since = since })
end
if second then
self:fadeIn(second, { delay = if self.pop then STAGGER else 0, slide = true, since = since })
end
end
function Ui.stateIcon(self: Ui, parent: Instance, state: State)
local colors = self.colors
if state.view == "working" then
local _, ring = spinner(parent, colors.accent, 24, 1)
ring.Rotation = self.spinAngle
self.parts.SpinnerRing = ring
if not self.still then
self:spin(ring)
end
return
end
local glyph, color
if state.view == "summary" then
glyph, color = "↓", colors.accent
elseif state.tone == "ok" then
glyph, color = "✓", colors.accent
elseif state.tone == "warn" then
glyph, color = "!", colors.warn
elseif state.tone == "error" then
glyph, color = "!", colors.error
else
glyph, color = "i", colors.text
end
local holder, circle = badge(parent, "Icon", glyph, color, 24, 1)
if self.pop and self.awake and not self.still then
local scale = Instance.new("UIScale")
scale.Scale = 0.6
scale.Parent = circle
self:tween(scale, { Scale = 1 }, POP)
if state.tone == "ok" then
task.delay(0.12, function()
if holder:IsDescendantOf(self.root) then
self:pulse(holder, color)
end
end)
end
end
end
function Ui.pulse(self: Ui, holder: GuiObject, color: Color3)
local ring = blank("Pulse")
ring.AnchorPoint = Vector2.new(0.5, 0.5)
ring.Position = UDim2.fromScale(0.5, 0.5)
ring.Size = UDim2.fromScale(1, 1)
corner(ring, -1)
local edge = stroke(ring, color, 2, 0.35)
local grow = Instance.new("UIScale")
grow.Scale = 0.8
grow.Parent = ring
ring.Parent = holder
self:tween(grow, { Scale = 1.7 }, PULSE)
self:tween(edge, { Transparency = 1 }, PULSE)
task.delay(PULSE.Time + 0.05, function()
ring:Destroy()
end)
end
function Ui.renderHome(self: Ui)
local colors = self.colors
local state = self.state
local main = self.parts.MainColumn
local holder = stack(main, "Card", 2, 8)
self.parts.Card = holder
self:button(holder, "ImportIdle", "Import", "primary", 1, function()
self:focusPaste()
self:nudge()
end, { full = true, muted = true, height = 38 })
local recent = stack(main, "Recent", 4, 8)
self.parts.Recent = recent
local lines = state.lines
if state.title ~= "" or (lines and #lines > 0) then
local card = self:card(recent, "Last", 1, 4)
card.BackgroundTransparency = 1
local heading = label(card, "Title", state.title, 12, colors.dim, Enum.FontWeight.SemiBold, 1)
self.parts.CardTitle = heading
if state.text and state.text ~= "" then
self.parts.CardText = label(card, "Text", state.text, 14, colors.strong, Enum.FontWeight.SemiBold, 2)
end
if lines then
for index, line in lines do
label(card, "Line" .. index, line, 13, colors.text, Enum.FontWeight.Regular, 2 + index)
end
end
end
local notes = state.notes
if notes then
for index, note in notes do
local text = label(recent, "Note" .. index, note, 12, colors.dim, Enum.FontWeight.Regular, 1 + index)
text.TextXAlignment = Enum.TextXAlignment.Center
end
end
end
function Ui.pageTitle(self: Ui, parent: Instance, title: string, doneName: string)
local row = blank("PageTitle", 1)
row.Size = UDim2.new(1, 0, 0, 32)
local text = label(row, "Title", title, 16, self.colors.strong, Enum.FontWeight.Bold, 1)
text.AnchorPoint = Vector2.new(0, 0.5)
text.Position = UDim2.fromScale(0, 0.5)
text.Size = UDim2.new(1, -90, 0, 0)
local done = self:button(row, doneName, "Done", "secondary", 2, function()
self:showPage("main")
end, { height = 30 })
done.AnchorPoint = Vector2.new(1, 0.5)
done.Position = UDim2.fromScale(1, 0.5)
row.Parent = parent
end
function Ui.heading(self: Ui, parent: Instance, text: string, order: number): TextLabel
return label(parent, "Heading", text, 13, self.colors.strong, Enum.FontWeight.Bold, order)
end
function Ui.renderSettings(self: Ui)
local column = self.parts.SettingsColumn
local old = self.parts.SettingsBody
if old then
old:Destroy()
self:prune()
end
local colors = self.colors
local body = stack(column, "Body", 1, 12)
self.parts.SettingsBody = body
self:pageTitle(body, "Settings", "SettingsDone")
local settingsState = self.settingsState
if settingsState == nil then
return
end
local where = self:card(body, "Where", 2, 4)
self:heading(where, "Where new designs go", 1)
local targets = stack(where, "Targets", 2, 0)
for index, choice in settingsState.targetChoices do
self:choice(targets, "Target_" .. choice.value, choice.label, settingsState.target == choice.value, index, function()
self.handlers.setTarget(choice.value)
end)
end
label(where, "TargetHint", "Select an earlier import (or a folder) before importing to use that instead.", 12, colors.dim, Enum.FontWeight.Regular, 3)
local owner = self:card(body, "Owner", 3, 4)
self:heading(owner, "Uploaded images belong to", 1)
local creators = stack(owner, "Creators", 2, 0)
local me = if settingsState.userName then "Me (" .. settingsState.userName .. ")" else "Me"
self:choice(creators, "Creator_user", me, settingsState.creatorKind == "user", 1, function()
self.handlers.setCreator("user", settingsState.groupId)
end)
self:choice(creators, "Creator_group", "A group", settingsState.creatorKind == "group", 2, function()
self.handlers.setCreator("group", settingsState.groupId)
end)
if settingsState.creatorKind == "group" then
local box = Instance.new("TextBox")
box.Name = "GroupId"
box.Size = UDim2.new(1, 0, 0, 32)
box.BackgroundColor3 = colors.background
box.BorderSizePixel = 0
box.ClearTextOnFocus = false
box.PlaceholderText = "Group id"
box.PlaceholderColor3 = colors.dim
box.Text = if settingsState.groupId then tostring(settingsState.groupId) else ""
box.TextColor3 = colors.strong
box.TextXAlignment = Enum.TextXAlignment.Left
box.TextTruncate = Enum.TextTruncate.AtEnd
box.FontFace = font(Enum.FontWeight.Regular)
box.TextSize = 14
box.LayoutOrder = 3
corner(box, 8)
local edge = stroke(box, colors.lineStrong)
padding(box, 0, 10, 0, 10)
box.Focused:Connect(function()
edge.Color = colors.accent
end)
box.FocusLost:Connect(function()
edge.Color = colors.lineStrong
local digits = string.match(box.Text, "^%s*(%d+)%s*$")
local id = digits and tonumber(digits)
self.handlers.setCreator("group", if id and id > 0 then id else nil)
end)
box.Parent = owner
self.parts.GroupId = box
if settingsState.groupId == nil then
label(owner, "GroupHint", "Type the group id (the number in the group's link) to upload images to the group.", 12, colors.warn, Enum.FontWeight.Medium, 4)
end
end
local memory = self:card(body, "Memory", 4, 8)
self:heading(memory, "Upload memory", 1)
local remembered = if settingsState.uploaded == 1 then "1 uploaded image remembered" else settingsState.uploaded .. " uploaded images remembered"
label(memory, "Uploaded", remembered .. " on this computer, so each image is uploaded once.", 13, colors.text, Enum.FontWeight.Regular, 2)
if settingsState.uploaded > 0 then
local row = flow(memory, "Row", 3, 8)
self:button(row, "Forget", "Forget uploaded images", "secondary", 1, self.handlers.forgetUploads, { height = 32 })
end
local check = settingsState.updateCheck
if check ~= nil then
local updates = self:card(body, "Updates", 5, 4)
self:heading(updates, "Updates", 1)
local choices = stack(updates, "Choices", 2, 0)
local function set(on: boolean)
local handler = self.handlers.setUpdateCheck
if handler then
handler(on)
end
end
self:choice(choices, "Updates_on", "Tell me when a new version is out", check, 1, function()
set(true)
end)
self:choice(choices, "Updates_off", "Don't check", not check, 2, function()
set(false)
end)
local site = (string.gsub(Brand.siteOrigin, "^%a+://", ""))
label(updates, "UpdatesHint", "Once a day it reads a small file from " .. site .. ". Nothing is sent.", 12, colors.dim, Enum.FontWeight.Regular, 3)
end
end
function Ui.renderHelp(self: Ui)
local column = self.parts.HelpColumn
local old = self.parts.HelpBody
if old then
old:Destroy()
self:prune()
end
local colors = self.colors
local tool = self.info.toolName
local body = stack(column, "Body", 1, 12)
self.parts.HelpBody = body
self:pageTitle(body, "Help", "HelpDone")
local how = self:card(body, "How", 2, 10)
self:heading(how, "Import a design", 1)
local steps = {
"In " .. tool .. ", click Export, then Copy for the Studio plugin.",
"Click the paste box and press Ctrl+V (Cmd+V on a Mac). A big design comes in parts: paste them one after another.",
"Check the summary and click Import. Ctrl+Z undoes the whole import.",
}
for index, step in steps do
local row = blank("Step" .. index, 1 + index)
row.Size = UDim2.new(1, 0, 0, 0)
row.AutomaticSize = Enum.AutomaticSize.Y
badge(row, "Number", tostring(index), colors.text, 20, 1)
local text = label(row, "Text", step, 13, colors.text, Enum.FontWeight.Regular, 2)
text.Position = UDim2.fromOffset(30, 1)
text.Size = UDim2.new(1, -30, 0, 0)
row.Parent = how
end
local update = self:card(body, "Update", 3, 6)
self:heading(update, "Update and send back", 1)
label(
update,
"Text",
"Import a new version the same way: the earlier import is updated in place, and your scripts stay. Export to designer saves the selected UI as a file for "
.. tool
.. ".",
13,
colors.text,
Enum.FontWeight.Regular,
2
)
local images = self:card(body, "Images", 4, 6)
self:heading(images, "Image uploads", 1)
label(
images,
"Text",
"Images are uploaded to your account (or a group, in Settings), once each. If Studio doesn't allow it: sign in, turn on File → Beta Features → CreateAssetAsync Luau API, then restart Studio.",
13,
colors.text,
Enum.FontWeight.Regular,
2
)
local guide = self:card(body, "Guide", 5, 8)
self:heading(guide, "The full guide", 1)
label(guide, "Text", "Plugins can't open a browser: click the address, press Ctrl+C, and paste it in your browser.", 13, colors.text, Enum.FontWeight.Regular, 2)
self.parts.Link = self:linkBox(guide, "Link", self.info.guideUrl, 3)
end
function Ui.refresh(self: Ui, part: string)
if self.destroyed then
return
end
local main: GuiObject? = self.parts.MainColumn
if main == nil or not main:IsDescendantOf(self.root) then
self:render()
return
end
if part == "Actions" then
self:renderPaste()
self:renderMore()
self:followLeave("main", self.parts.Paste, self.parts.More)
elseif part == "Card" then
self:renderCard()
self:followLeave("main", self.parts.Card, self.parts.Recent)
elseif part == "Notices" then
self:renderNotices()
self:followLeave("main", self.parts.Notices)
else
self:renderSettings()
self:renderHelp()
self:followLeave("settings", self.parts.SettingsBody)
self:followLeave("help", self.parts.HelpBody)
end
self:prune()
end
local NEEDS_LOOK = { pasting = true, summary = true, blocked = true, done = true, error = true }
function Ui.show(self: Ui, state: State)
local previous = self.state
local wasBusy = previous.busy == true
self.state = state
local fresh = state.view ~= previous.view or state.title ~= previous.title
self.pop = fresh
if wasBusy ~= (state.busy == true) then
self:refresh("Actions")
end
self:refresh("Card")
self.pop = false
local look = self.pasteLook
if look then
look()
end
if fresh and NEEDS_LOOK[state.view] and self.page ~= "main" then
self:showPage("main")
end
end
function Ui.setSettings(self: Ui, settingsState: SettingsState)
self.settingsState = settingsState
self:refresh("Settings")
end
function Ui.setNotices(self: Ui, notices: { Notice })
self.notices = notices
self:refresh("Notices")
end
function Ui.press(self: Ui, name: string): boolean
for item, action in self.actions do
if item.Name == name and shown(item, self.root, self.leaving) then
action()
return true
end
end
return false
end
function Ui.poke(self: Ui, name: string, state: string): boolean
for item, look in self.looks do
if item.Name == name and shown(item, self.root, self.leaving) then
look(state)
return true
end
end
return false
end
function Ui.texts(self: Ui): { string }
local out = {}
for _, item in self.root:GetDescendants() do
if (item:IsA("TextLabel") or item:IsA("TextButton") or item:IsA("TextBox")) and item.Text ~= "" and self:built(item, "TextTransparency") < 1 and shown(item, self.root, self.leaving) then
table.insert(out, item.Text)
end
end
return out
end
function Ui.destroy(self: Ui)
self.destroyed = true
for _, connection in self.connections do
connection:Disconnect()
end
table.clear(self.connections)
for _, tween in self.loops do
tween:Cancel()
end
table.clear(self.loops)
table.clear(self.actions)
table.clear(self.looks)
table.clear(self.resting)
table.clear(self.leaving)
self.root:Destroy()
end
return Ui
]]>
-
Updates
4 * Updates.MAX_LINE or utf8.len(value) == nil then
return nil
end
local text = string.gsub(value, "%c", " ")
text = string.gsub(text, "%s+", " ")
text = string.match(text, "^%s*(.-)%s*$") or ""
if text == "" then
return nil
end
local length = utf8.len(text) or 0
if length > Updates.MAX_LINE then
local cut = utf8.offset(text, Updates.MAX_LINE) or (#text + 1)
text = (string.match(string.sub(text, 1, cut - 1), "^(.-)%s*$") or "") .. "…"
end
return text
end
function Updates.release(value: any): Release?
if type(value) ~= "table" then
return nil
end
local release = Version.release(value.release)
if Version.parse(value.version) == nil or release == nil then
return nil
end
return {
version = value.version,
release = release,
notes = Updates.line(value.notes),
url = Updates.siteUrl(value.guide or value.url),
}
end
function Updates.read(text: any): Release?
if type(text) ~= "string" or #text > Updates.MAX_BYTES then
return nil
end
local ok, data = pcall(HttpService.JSONDecode, HttpService, text)
if not ok or type(data) ~= "table" or data.format ~= "nighty-version" then
return nil
end
return Updates.release(data)
end
function Updates.due(state: Settings.UpdateState, now: number): boolean
if state.off then
return false
end
local at = state.checkedAt
return at == nil or now - at >= Updates.EVERY or now < at
end
function Updates.shown(state: Settings.UpdateState, pasted: Release?, own: number): Release?
local best = if state.off then nil else Updates.release(state.newest)
if pasted and (best == nil or pasted.release > best.release) then
best = pasted
end
if best == nil or best.release <= own then
return nil
end
local later = state.later
if later and best.release <= later then
return nil
end
return best
end
function Updates.check(settings: Settings.Settings, fetch: (url: string) -> string, now: number): Release?
local before = settings:updates()
if not Updates.due(before, now) then
return nil
end
local looked = table.clone(before)
looked.checkedAt = now
settings:setUpdates(looked)
local ok, text = pcall(fetch, Brand.versionUrl)
local found = if ok then Updates.read(text) else nil
if found == nil then
return nil
end
local state = table.clone(settings:updates())
state.newest = found
settings:setUpdates(state)
return found
end
return Updates
]]>
-
Uploader
Security > Allow Mesh / Image APIs, turn it on and import again.",
}
end
local written, writeError = pcall(function()
editable:WritePixelsBuffer(Vector2.zero, size, image.pixels)
end)
if not written then
editable:Destroy()
return nil, { kind = "failed", message = "The image could not be prepared (" .. tostring(writeError) .. ")." }
end
local parameters: { [string]: any } = {
Name = name,
Description = description,
CreatorId = creator.id,
CreatorType = if creator.kind == "group" then Enum.AssetCreatorType.Group else Enum.AssetCreatorType.User,
}
local called, result, idOrMessage = pcall(function()
return AssetService:CreateAssetAsync(editable, Enum.AssetType.Image, parameters)
end)
editable:Destroy()
if not called then
return nil, fromError(tostring(result))
end
if result == Enum.CreateAssetResult.Success then
local id = tonumber(idOrMessage)
if id and id > 0 then
return id, nil
end
return nil, { kind = "failed", message = "Roblox didn't send back the new image's id." }
elseif result == Enum.CreateAssetResult.PermissionDenied then
return nil,
{
kind = "blocked",
message = if creator.kind == "group"
then "Roblox says you can't create assets in group " .. creator.id .. "."
else "Roblox says this account can't upload images right now.",
}
end
return nil, fromResult(tostring(idOrMessage or result))
end
return Uploader
]]>
-
Version
32 then
return nil
end
local major, minor, patch = string.match(value, "^(%d+)%.(%d+)%.(%d+)$")
if major == nil or minor == nil or patch == nil then
return nil
end
return { tonumber(major) :: number, tonumber(minor) :: number, tonumber(patch) :: number }
end
function Version.newer(a: any, b: any): boolean
local x, y = Version.parse(a), Version.parse(b)
if x == nil or y == nil then
return false
end
for index = 1, 3 do
if x[index] ~= y[index] then
return x[index] > y[index]
end
end
return false
end
function Version.release(value: any): number?
if type(value) ~= "number" or value ~= value or value < 1 or value > 1e6 or math.floor(value) ~= value then
return nil
end
return value
end
return Version
]]>
-
Zip
MAX_ENTRIES then
Errors.fail("This file holds too many files for the plugin to read.", "zip: " .. count .. " entries")
end
if directoryOffset + directorySize > eocd then
Errors.fail(DAMAGED, "zip: central directory out of range")
end
local archive: Archive = { data = data, entries = {}, byName = {} }
local pos = directoryOffset
for _ = 1, count do
if pos + 46 > eocd or readu32(data, pos) ~= 0x02014b50 then
Errors.fail(DAMAGED, "zip: bad central directory entry")
end
local nameLength = readu16(data, pos + 28)
local extraLength = readu16(data, pos + 30)
local commentLength = readu16(data, pos + 32)
if pos + 46 + nameLength + extraLength + commentLength > eocd then
Errors.fail(DAMAGED, "zip: entry runs past the directory")
end
local entry: Entry = {
name = (string.gsub(buffer.readstring(data, pos + 46, nameLength), "\\", "/")),
flags = readu16(data, pos + 8),
method = readu16(data, pos + 10),
crc = readu32(data, pos + 16),
compressedSize = readu32(data, pos + 20),
size = readu32(data, pos + 24),
headerOffset = readu32(data, pos + 42),
}
pos += 46 + nameLength + extraLength + commentLength
if string.sub(entry.name, -1) ~= "/" and archive.byName[entry.name] == nil then
table.insert(archive.entries, entry)
archive.byName[entry.name] = entry
end
end
return archive
end
function Zip.read(archive: Archive, entry: Entry): buffer
local data = archive.data
local size = buffer.len(data)
if bit32.band(entry.flags, 1) ~= 0 then
Errors.fail("This file is password-protected. Export it again from " .. Brand.productName .. ".", "zip: encrypted entry")
end
if entry.size > MAX_FILE_SIZE then
Errors.fail("A file inside the design file is too big for the plugin to read.", "zip: " .. entry.name .. " too big")
end
local header = entry.headerOffset
if header + 30 > size or readu32(data, header) ~= 0x04034b50 then
Errors.fail(DAMAGED, "zip: bad local header for " .. entry.name)
end
local start = header + 30 + readu16(data, header + 26) + readu16(data, header + 28)
if start + entry.compressedSize > size then
Errors.fail(DAMAGED, "zip: data of " .. entry.name .. " runs past the end")
end
local out: buffer
if entry.method == 0 then
if entry.compressedSize ~= entry.size then
Errors.fail(DAMAGED, "zip: stored sizes differ for " .. entry.name)
end
out = buffer.create(entry.size)
buffer.copy(out, 0, data, start, entry.size)
elseif entry.method == 8 then
out = Inflate.raw(data, start, entry.compressedSize, entry.size)
else
Errors.fail(
"This file uses a kind of compression " .. Brand.pluginName .. " can't read. Export it again from " .. Brand.productName .. ".",
"zip: method " .. entry.method .. " for " .. entry.name
)
end
if Checksum.crc32(out, 0, entry.size) ~= entry.crc then
Errors.fail(DAMAGED, "zip: CRC mismatch for " .. entry.name)
end
return out
end
function Zip.find(archive: Archive, name: string): Entry?
return archive.byName[name]
end
return Zip
]]>