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 l'apertura ScriptDocument corrispondente allo script dato LuaSourceContainer , o nil se lo script dato 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 di modifica per lo script dato.

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

Parametri

Restituzioni

Restituisce un array di documenti di 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 una richiamata di completamento automatico chiamata con priorità .

Quando l'Editor di script invoca l'autocompletamento, tutte le richieste e le risposte di autocompletamento registrate vengono chiamate in ordine crescente di priorità con la richiesta e la risposta di autocompletamento.Diverse richieste di ritorno possono condividere una priorità, ma poi il loro ordine di chiamata è imprevedibile.Ogni richiamo è destinato a restituire una tabella di risposta con lo stesso formato della tabella di input di risposta.Le chiamate di ritorno non dovrebbero produrre.La prima chiamata di richiamo invocata riceve la risposta dell'autocompletamento interno come tabella delle risposte, e le successive chiamate di richiamo ricevono l'output della chiamata precedente come tabella delle risposte.I richiami possono modificare il tavolo passato o restituire un nuovo tavolo dello stesso formato.

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

La tabella delle richieste ha il seguente formato:

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

• position è la posizione del cursore a un indice dove stai completando automaticamente.
• textDocument.document è l'apertura ScriptDocument 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 l'uno all'altro: req.textDocument.document:GetScript() == req.textDocument.script

La tabella delle risposte 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,
        insert: { start: { line: number, character: number }, ["end"]: { line: number, character: number } },
        replace: { start: { line: number, character: number }, ["end"]: { line: number, character: number } },
      }?
    }
  }
}

• Response.items è un array degli elementi di completamento. L'ordine di questo array è insignificante e si ricorre nell'editor come l'utente digita.
• Response.items[n].label è l'etichetta dell'elemento che viene visualizzato nel menu di completamento automatico.
• Response.items[n].kind specifica quale tipo di oggetto di completamento automatico questo è.Principalmente questo controlla l'icona data all'elemento nell'editor.Non tutti i tipi hanno un'Iconaunica.Se non specificato, l'editor utilizza l'Icona"Testo".I tipi non supportati predefiniscono la visualizzazione dell'Icona"Proprietà".
• Response.items[n].tags specifica un array di tag che descrivono questo oggetto di completamento. Vedi il Enum.CompletionItemTag per i dettagli sulla loro funzione.
• Response.items[n].details specifica una stringa che descrive i dettagli sull'elemento di completamento.Per gli elementi predefiniti, questa è una rappresentazione a stringa del loro inserisci / scrivi.Nota che, affinché il widget di documentazione venga visualizzato, 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 di documentazione viene visualizzata se vengono specificati dettagli o sovraccarichi.
• Response.items[n].overloads specifica il numero di sovraccarichi di una completamento automatico di funzione.
• Response.items[n].learnMoreLink link a una pagina pertinente sulle doc del creatore.Questo URL deve essere una richiesta https a creare.roblox.com; nessun altro URL viene visualizzato nell'editor.
• Response.items[n].codeSample specifica un uso di prova dell'articolodi completamento. documentation deve essere non vuoto per visualizzare questo campo.
• Response.items[n].preselect Se vero, l'editor ordina questo elemento di 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 della conclusione applica questa modifica del testo - inserendo o sostituendo lo spazio tra le posizioni di inizio e fine con il nuovo testo.

Se un callback restituisce un risultato non formattato o incontra un errore, l'editor scarta la tabella di risposta modificata e utilizza la lista di completamento automatica integrata.

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 un callback di analisi dello script callbackFunction chiamato name con priority .Quando l'analisi dello script in Studio viene eseguita, tutti i richiami registrati vengono chiamati in ordine crescente di priorità.Ogni richiamo è destinato a restituire una tabella di risposta che corrisponde al formato specificato qui sotto.I richiami non dovrebbero produrre.

La tabella delle richieste ha il seguente formato, dove script è il LuaSourceContainer che verrà analizzato.

type Request = {
  script: LuaSourceContainer?
}

La tabella delle risposte ha il seguente formato, in cui diagnostics è un array di tabelle diagnostiche. Ogni tabella diagnostica ha le voci elencate qui sotto.

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 un intervallo di testo che deve essere evidenziato dal linter, fornendo quale linea/personaggio per iniziare ad evidenziare e quale linea/personaggio per smettere di evidenziare.
• code è un'etichetta per il messaggio.
• message è un messaggio di avvertimento da mostrare per la linea.Questo apparirà anche in una nota quando l'utente passa il cursore sulle linee nell'Editor di script.
• severity è un valore Enum.Severity per la diagnostica.Questo determina come la diagnosi sia categorizzata nell'attrezzo di analisi dello script in Studio, nonché come il testo venga evidenziato nell'editor degli script.
• codeDescription link a una pagina pertinente sulle doc del creatore. Questo 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)

Richieste che un Editor di script apra lo script specificato.Restituisce (vero, nil) se la richiesta ha successo.Restituisce (false, Stringa) se la richiesta fallisce, con una stringa che descrive il problema.

Se lo script è già aperto, questa funzione ha successo e cambia scheda 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 dato.

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

Se lo script è aperto nell' Editor di script, poi invia una richiesta all'editor per aggiornare la sua Sorgente.L'editor può rifiutare questo aggiornamento se la proprietà Script.Source era scaduta con la versione dello script dell'utente quando questa funzione è stata chiamata, in tal caso il richiamo verrà ri-invocato e il tentativo verrà ripetuto.

Il richiamo potrebbe non produrre.Se il richiamo restituisce nil , l'operazione viene annullata.Questa funzione produce fino a quando l'operazione non viene annullata o ha successo.

Se lo script non è aperto nell'editor, i nuovi aggiornamenti del contenuto vengono aggiunti alla Sorgentedello script, che è il testo che l'editor visualizzerebbe se viene aperto.

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

Parametri

Restituzioni

Fuochi appena dopo un ScriptDocument cambiamenti. Il textChanged è un array di strutture di cambio 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)

Fuochi appena prima che un oggetto ScriptDocument venga distrutto, che accade subito dopo che il editor di script si chiude.Dopo questo evento di fuochi, il ScriptDocument entra in uno stato "Chiuso", e tentando di chiamare i suoi metodi viene generato un errore. ScriptDocument gli oggetti non sono riutilizzabili, anche se l'editor di script riapre lo stesso script.

Parametri

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

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

Fuochi appena dopo che un oggetto ScriptDocument è stato creato e affidato al servizio, che avviene subito dopo l'apertura dell'editor di script.

Parametri

--!nocheck

-- Run the following code in the Command Bar

local ScriptEditorService = game:GetService("ScriptEditorService")

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