ScriptEditorService

Remove um retorno de chamada previamente registrado com o nome name .

Parâmetros

Devolução

game.ScriptEditorService:DeregisterAutocompleteCallback("foo")

Remove um retorno de chamada previamente registrado com o nome name .

Parâmetros

Devolução

local ScriptEditorService = game:GetService("ScriptEditorService")

ScriptEditorService:DeregisterScriptAnalysisCallback("foo")

Retorna o ScriptDocument aberto correspondente ao LuaSourceContainer dado, ou nil se o script não for aberto.

Parâmetros

Devolução

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

local documents = ScriptEditorService:GetScriptDocuments()
local scriptDocument
-- Find the first open script document
for _, document in documents do
	-- The Command Bar can't be closed, so don't select it
	if not document:IsCommandBar() then
		scriptDocument = document
		break
	end
end

if scriptDocument then
	local success, err = scriptDocument:CloseAsync()
	if success then
		print(`Closed {scriptDocument.Name}`)
	else
		warn(`Failed to close {scriptDocument.Name} because: {err}`)
	end
else
	print("No open scripts")
end

--!nocheck

--[[
	To run:
		1. Ensure Output view is open
		2. Run the below code in the Command Bar
		3. Scroll up and down in the opened Script window

	Print statements from the ViewportChanged event will appear in the Output
]]

local Workspace = game:GetService("Workspace")
local ScriptEditorService = game:GetService("ScriptEditorService")

-- Create text that spans many lines
local dummyText = string.rep("-- Dummy Text\n", 60)

-- Create a script containing the dummy text and open it
local otherScript = Instance.new("Script")
otherScript.Source = dummyText
otherScript.Parent = Workspace
local success, err = ScriptEditorService:OpenScriptDocumentAsync(otherScript)
if not success then
	warn(`Failed to open script because: {err}`)
	return
end

-- Get a reference to the opened script
local scriptDocument = ScriptEditorService:FindScriptDocument(otherScript)

local function onViewportChanged(startLine: number, endLine: number)
	print(`Script Viewport Changed - startLine: {startLine}, endLine: {endLine}`)
end
-- Connect the ViewportChanged event to the function above that prints the start and end line of the updated viewport
scriptDocument.ViewportChanged:Connect(onViewportChanged)

Retorna a fonte de edição para o script fornecido.

Se o script estiver aberto no Editor de Scripts, este método retorna o texto atualmente exibido no editor. Se o script não estiver aberto no editor, o método retorna o texto que o editor exibiria se fosse aberto. A fonte de tempo de edição não é sempre consistente com a propriedade Script.Source.

Parâmetros

Devolução

Retorna um array dos documentos de script atualmente abertos, incluindo a barra de comandos.

Devolução

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

local scriptDocuments = ScriptEditorService:GetScriptDocuments()
for _, scriptDocument in scriptDocuments do
	-- Prints the name of each script
	if not scriptDocument:IsCommandBar() then
		print(scriptDocument.Name)
	end
end

Registra um retorno de chamada de autocompletar callbackFunction chamado name com prioridade priority.

Quando o Editor de Script invoca autocompletar, todos os retornos de chamada de autocompletar são chamados de acordo com a prioridade crescente com a solicitação e resposta de autocompletar. Múltiplos retornos de chamada podem compartilhar uma prioridade, mas então sua ordem de chamada é imprevisível. C

A callbackFunction deve ter o seguinte digitar: (Request: table, Response: table) -> table

A tabela Request tem o seguinte formato:

type Request = {
  position: {
    line: number,
    character: number
  },
  textDocument: {
    document: ScriptDocument?,
    script: LuaSourceContainer?
  }
}

• position é a posição de cursor de um índice onde você está autocompletando.
• textDocument.document é o ScriptDocument aberto que você está completando, se ele existir.
• textDocument.script é o LuaSourceContainer que você está completando, se ele existir.

Se ambos textDocument.document e textDocument.script estiverem presentes, então eles correspondem um ao outro: req.textDocument.document:GetScript() == req.textDocument.script

A tabela Resposta tem o seguinte formato:

type Response = {
  items: {
    {
      label: string, -- The label
      kind: Enum.CompletionItemKind?,
      tags: {Enum.CompletionItemTag}?,
      detail: string?,
      documentation: {
        value: string,
      }?,
      overloads: number?,
      learnMoreLink: string?,
      codeSample: string?,
      preselect: boolean?,
      textEdit: {
        newText: string,
        replace: { start: { line: number, character: number }, ["end"]: { line: number, character: number } },
      }?
    }
  }
}

• Response.items é um array dos itens de conclusão. A ordem deste array é insignificante, e ele ressurgi no editor como os tipos de usuário.
• Response.items[n].label é a etiqueta do item que é exibido no menu de autocompletar.
• Response.items[n].kind especifica que tipo de item de autocompletamento é este. Primáriomente isso controla o ícone dado ao item no editor. Não todos os tipos têm um ícone único. Se não especificado, o editor usa o ícone "Texto". Não-suportados padrão para exibir o ícone "Propriedade".
• Response.items[n].tags especifica um conjunto de tags descrevendo este item de conclusão. Veja o Enum.CompletionItemTag para detalhes sobre sua função.
• Response.items[n].details especifica uma string que descreve detalhes sobre o item de conclusão. Para itens padrão, isso é uma representação de digitarde string. Observe que, para que o widget de documentos seja exibido, documentation deve estar presente, mas documentation.value pode estar vazio.
• Response.items[n].documentation especifica o corpo principal da documentação em seu campo value. documentation está presente, mesmo que o valor esteja vazio, para que a janela de documentação seja exibida, seja que detalhes ou overloads sejam especificados.
• Response.items[n].overloads especifica o número de overloads de uma função de autocompletamento.
• Response.items[n].learnMoreLink links para uma página relevante nos docs do criador. Este URL deve ser um pedido https para Criar.roblox.com; nenhum outro URL será exibido no editor.
• Response.items[n].codeSample especifica um uso de exemplo do item de conclusão. documentation deve ser não vazio para exibir este campo.
• Response.items[n].preselect Se for verdadeiro, o editor sorteia este item de conclusão antes de todos os outros e seleciona-o para o usuário por padrão. Sem efeito se for falso ou faltando.
• Response.items[n].textEdit Se presente, aceitar a conclusão aplica este texto editado - substituindo a espaçamento entre as posições início e fim com o novoTexto.

Se um retorno de chamada retornar um resultado malformado ou encontrar um erro, o editor descarta a tabela de resposta modificada e usa a lista de resultados de autocompletamento incorporada.

Parâmetros

Devolução

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

type Request = {
	position: {
		line: number,
		character: number,
	},
	textDocument: {
		document: ScriptDocument?,
		script: LuaSourceContainer?,
	},
}

type Response = {
	items: {
		{
			label: string,
			kind: Enum.CompletionItemKind?,
			tags: { Enum.CompletionItemTag }?,
			detail: string?,
			documentation: {
				value: string,
			}?,
			overloads: number?,
			learnMoreLink: string?,
			codeSample: string?,
			preselect: boolean?,
			textEdit: {
				newText: string,
				replace: {
					start: { line: number, character: number },
					["end"]: { line: number, character: number },
				},
			}?,
		}
	},
}

local autocompleteCallback = function(request: Request, response: Response): Response
	local item = {
		label = "foo",
		preselect = true,
	}
	table.insert(response.items, item)
	return response
end

ScriptEditorService:RegisterAutocompleteCallback("foo", 1, autocompleteCallback)

-- To deregister the callback, run the following code in the Command Bar

ScriptEditorService:DeregisterAutocompleteCallback("foo")

Registra um retorno de chamada de análise de script callbackFunction chamado name com priority . Quando a análise de script no Studio é executada, todos os retornos de chamada registrados são chamados em ordem crescente de prioridade. Cada retorno de chamada é intencionado para retornar uma tabela de resposta correspondendo ao formato especificado abaixo. Os retornos de chamada não devem retornar.

A tabela de pedido tem o seguinte formato, onde script é o LuaSourceContainer que será analisado.

type Request = {
  script: LuaSourceContainer?
}

A tabela de resposta tem o seguinte formato, onde diagnostics é um array de tabelas de diagnóstico. Cada tabela de diagnóstico tem as entradas listadas abaixo.

type Response = {
  diagnostics: {
    {
      range: {
        start: {
          line: number,
          character: number,
        },
        ["end"]: {
          line: number,
          character: number,
        }
      },
      code: string?,
      message: string,
      severity: Enum.Severity?,
      codeDescription: { href: string }?
    }
  }
}

• range representa uma faixa de texto que deve ser destacada pelo linter, fornecendo qual linha/caractere para iniciar o destaque e qual linha/caractere para terminar o destaque.
• code é uma etiqueta para a mensagem.
• message é uma mensagem de aviso para ser exibida para a linha. Isso também aparecerá em uma caixa de diálogo quando o usuário passar o cursor sobre a linha no Editor de Scripts.
• severity é um valor de Enum.Severity para os diagnósticos. Isso determina como o diagnóstico é categorizado na ferramenta de Análise de Script no Studio, bem como como o texto é destacado na Editor de Script.
• codeDescription links para uma página relevante nos docs do criador. Este URL deve ser um pedido https para create.roblox.com; nenhum outro URL é exibido no editor.

Parâmetros

Devolução

type Request = {
  ["script"]: LuaSourceContainer,
}

type Response = {
  diagnostics: {
    {
      range: {
        start: {
          line: number,
          character: number,
        },
        ["end"]: {
          line: number,
          character: number,
        }
      },
      code: string?,
      message: string,
      severity: Enum.Severity?,
      codeDescription: { href: string }?,
    }
  }
}

local ScriptEditorService = game:GetService("ScriptEditorService")

ScriptEditorService:RegisterScriptAnalysisCallback("foo", 1, function(
  Req : Request): Response
  local response = {
    diagnostics = {}
  }
  local lineNo = 1
  
  -- Iterate line by line
  for text, newline in Req.script.Source:gmatch("([^\r\n]*)([\r\n]*)") do

    local startIndex, endIndex = string.find(text, "Foo")
    if startIndex and endIndex then
      table.insert(response.diagnostics, {
        range = {
          ["start"] = {
            line = lineNo,
            character = startIndex,
          },
          ["end"] = {
            line = lineNo,
            character = endIndex,
          },
        },
        code = "FooFinder",
        message = "Foo found here!",
        severity = Enum.Severity.Warning,
      })
    end
    lineNo = lineNo + #newline:gsub("\n+", "\0%0\0"):gsub(".%z.", "."):gsub("%z", "")
  end
  return response
end)

Solicitações que um Editor de Script abra o script especificado. Retorna (verdadeiro, nil) se a solicitação tiver sucesso. Retorna (falso, string / cadeia / texto) se a solicitação falhar, com uma string que descreve o problema.

Se o script já estiver aberto, esta função terá sucesso e alternará as guias para o editor associado.

Parâmetros

Devolução

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")
local Workspace = game:GetService("Workspace")

local newScript = Instance.new("Script")
newScript.Parent = Workspace

local success, err = ScriptEditorService:OpenScriptDocumentAsync(newScript)
if success then
	print("Opened script document")
else
	print(`Failed to open script document: {err}`)
end

Retorna o tempo de edição Script.Source para o script fornecido.

Essa função chama o retorno de chamada usado no script para calcular os novos conteúdos do script.

Se o script estiver aberto no Editor de Scripts, então ele envia uma solicitação ao editor para que ele atualize sua original. O editor pode rejeitar essa atualização se a propriedade Script.Source estiver desatualizada com a versão do usuário quando essa função for chamada, o que resultará em um retorno de chamada e uma nova tentativa.

O retorno de chamada pode não ser obtido. Se o retorno de chamada retornar nil, a operação é cancelada. Essa função é gerada até que a operação seja cancelada ou seja um sucesso.

Se o script não for aberto no editor, as novas atualizações de conteúdo serão feitas na originaldo script, que é o texto que o editor exibiria se fosse aberto.

local ses = game:GetService('ScriptEditorService')
ses:UpdateSourceAsync(Workspace.Script, function(oldContent)
  return oldContent .. " World!"
end)

Parâmetros

Devolução

Só é ScriptDocument alterações após. O textChanged é uma matriz de estruturas de mudança do formato:

{ range : { start : { line : number, character : number }, end : { line : number, character : number } }, text: string }

Parâmetros

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

ScriptEditorService.TextDocumentDidChange:Connect(function(scriptDocument, changes)
	print("Changed", scriptDocument, changes)
end)

Fires apenas antes de um ScriptDocument objeto ser destruído, o que acontece imediatamente depois que o editor de scripts fecha. Depois desse evento, os ScriptDocument entra em um estado de "Fechado", e tentar chamar seus métodos apresenta um erro. ScriptDocument objetos não são reutilizáveis, mesmo que o editor de scripts re

Parâmetros

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

ScriptEditorService.TextDocumentDidClose:Connect(function(scriptDocument)
	print("Closed", scriptDocument)
end)

Ocorre imediatamente após a criação de um objeto ScriptDocument e associá-lo ao serviço, o que acontece imediatamente após o editor de scripts abrir.

Parâmetros

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

ScriptEditorService.TextDocumentDidOpen:Connect(function(scriptDocument)
	print("Opened", scriptDocument)
end)