ScriptEditorService

Rimuove un callback precedentemente registrato con il nome name .

Parametri

Restituzioni

game.ScriptEditorService:DeregisterAutocompleteCallback("foo")

Rimuove un callback precedentemente registrato con il nome name .

Parametri

Restituzioni

local ScriptEditorService = game:GetService("ScriptEditorService")

ScriptEditorService:DeregisterScriptAnalysisCallback("foo")

Restituisce il ScriptDocument aperto corrispondente al LuaSourceContainer , o nullo se lo script specificato non è aperto.

Parametri

Restituzioni

--!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)

Restituisce la fonte dell'edit-time per lo script specificato.

Se lo script è aperto nel Editor del Script, questo metodo restituisce il testo che viene visualizzato attualmente nell'editor. Se lo script non è aperto nell'editor, il metodo restituisce il testo che l'editor mostrerebbe se fosse aperto. La fonte di tempo di modifica non è sempre coerente con la ProprietàScript.Source.

Parametri

Restituzioni

Restituisce un array dei documenti script attualmente aperti, inclusa la barra dei comandi.

Restituzioni

--!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 un callback di autocompletamento callbackFunction chiamato name con priorità priority .

Quando lo script editor invoca autocompletamento, tutti i richiami di script autocompletamento registrati chiamano in ordine crescente con la richiesta e la risposta di autocompletamento. Più richiami possono condividere una priorità, ma poi il loro ordine di chiamata non è prevedibile. Ogni richiamo è destinato a restituire una tabella di risposta

Il callbackFunction deve avere il seguente inserisci / scrivi: (Request: table, Response: table) -> table

La tabella richiesta ha il seguente formato:

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

• position è la posizione del cursore a uno script in cui si autocompleta.
• textDocument.document è il ScriptDocument aperto che stai completando, se esiste.
• textDocument.script è il LuaSourceContainer che stai completando, se esiste.

Se entrambi textDocument.document e textDocument.script sono presenti, allora corrispondono tra loro: req.textDocument.document:GetScript() == req.textDocument.script

La tabella Risposta ha il seguente 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 è un array degli oggetti di completamento. L'ordine di questo array è irrilevante e viene riutilizzato nell'editor come tipo di utente.
• Response.items[n].label è il titolo dell'elemento che viene visualizzato nel menu di autocompletamento.
• Response.items[n].kind specifica quale tipo di autocompletamento item questo è. In primo luogo, questo controlla il tipo di icon che viene fornito dall'elemento nell'editor. Tutti i tipi non hanno un'Iconaunica. Se non specificato, l'editor usa l'Icona"Testo". I tipi non supportati predefinono di visualizzare l'Icona"Proprietà".
• Response.items[n].tags specifies an array of tags describing this completion Articolo. See the Enum.CompletionItemTag for details on their function.
• Response.items[n].details specifica una stringa che descrive i dettagli sull'elemento di completamento. Per gli elementi predefiniti, questa è una rappresentazione di tipo stringa del loro inserisci / scrivi. Nota che, per consentire al widget della documentazione di visualizzare, documentation deve essere presente, ma documentation.value può essere vuoto.
• Response.items[n].documentation specifica il corpo principale della documentazione nel suo campo value . documentation è presente, anche se il valore è vuoto, quindi la finestra della documentazione mostra se sono specificati dettagli o over載.
• Response.items[n].overloads specifica il numero di overload di una funzione autocompletamento.
• Response.items[n].learnMoreLink link a una pagina rilevante sui creatori docs. Questo URL deve essere una richiesta https per creare.roblox.com; nessun altro URL viene visualizzato nell'editor.
• Response.items[n].codeSample specifica un esempio di utilizzo dell'Articolodi completamento. documentation deve essere non vuoto per visualizzare questo campo.
• Response.items[n].preselect Se è vero, l'editor sortisce questo completamento prima di tutti gli altri e lo seleziona per l'utente per impostazione predefinita. Nessun effetto se falso o mancante.
• Response.items[n].textEdit Se presente, l'accettazione dell'完成o si applica a questo testo edit - sostituendo lo spazio tra le posizioni iniziali e finali con nuovoTesto.

Se un callback restituisce un risultato non valido o incontra un errore, l'editor scarta la tabella di risposta modificata e utilizza la lista di risultati autocompletamento incorporata.

Parametri

Restituzioni

--!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 una richiamata di analisi dello script callbackFunction con il nome name con priority . Quando viene eseguita l'analisi dello script in Studio, tutte le richiamate di script vengono chiamate in modo ascendente di priorità. Ogni richiamata di script è destinata a restituire una tabella di risposta corrispondente al formato specificato di seguito. Le richiamate non dovrebbero essere restituite.

La tabella di richiesta ha il seguente formato, in cui script è il LuaSourceContainer che sarà analizzato.

type Request = {
  script: LuaSourceContainer?
}

La tabella di risposta ha il seguente formato, in cui diagnostics è un'arrangione di tabelle di diagnosi. Ogni tabella di diagnosi ha gli elementi elencati di seguito.

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 rappresenta una gamma di testo che dovrebbe essere evidenziata dal linter, fornendo quale riga/carattere per iniziare l'evidenziazione e quale riga/carattere per terminare l'evidenziazione.
• code è un'etichetta per il messaggio.
• message è un messaggio di avviso da mostrare per la linea. Questo apparirà anche in una tooltip quando l'utente passa il mouse sulla linea nell'Editor del Script.
• severity è un valore Enum.Severity per i diagnostics. Ciò determina il modo in cui il diagnostics viene categorizzato nell'strumento di analisi dello script in Studio, nonché il modo in cui il test viene evidenziato nell'strumento di editor del script.
• codeDescription link a una pagina pertinente nei docs del creatore. Questa URL deve essere una richiesta https a create.roblox.com; nessun altro URL viene visualizzato nell'editor.

Parametri

Restituzioni

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)

Richiede che uno script editor apra lo script specificato. Ritorna (vero, null) se la richiesta ha successo. Ritorna (false, Stringa) se la richiesta fallisce, con una stringa che descrive il problema.

Se lo script è già aperto, questa funzione ha successo e passa le schede all'editor associato.

Parametri

Restituzioni

--!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

Restituisce il tempo di modifica Script.Source per lo script specificato.

Questa funzione chiama il vecchio callback utilizzando i vecchi contenuti dello script per calcolare i nuovi contenuti dello script.

Se lo script è aperto nel Editor del Script , allora emette una richiesta all'editor per aggiornare la sua Sorgente. L'editor potrebbe rifiutare questo aggiornamento se la proprietà Script.Source era scaduta con la versione dell'utente della script quando questa funzione è stata chiamata, in cui caso il callback viene ri-invocato e l'attento viene ripetuta.

Il callback potrebbe non essere in grado di generare. Se il callback restituisce nil, l'operazione viene annullata. Questa funzione genera fino a quando l'operazione non viene annullata o il successo.

Se lo script non viene aperto nell'editor, il nuovo contenuto viene aggiornato alla Sorgentedello script, che è il testo che l'editor visualizza se viene aperto.

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

Parametri

Restituzioni

Spara appena dopo un cambiamento in ScriptDocument . Il textChanged è un array di strutture di cambiamento del formato:

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

Parametri

--!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)

Spara appena prima che un oggetto ScriptDocument sia distrutto, che avviene proprio dopo che lo script editor chiude. Dopo questo evento, l'ScriptDocument entra in uno stato "chiuso", e cercando di chiamare i suoi metodi si ottiene un errore. Gli oggetti ScriptDocument non sono riutilizzabili, anche se lo script editor riapre lo

Parametri

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

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

Si attiva appena un oggetto ScriptDocument viene creato e parented al servizio, che avviene proprio dopo che lo script editor apre.

Parametri

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

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