ScriptEditorService

Elimina un llamado de registro previo con el nombre name .

Parámetros

Devuelve

game.ScriptEditorService:DeregisterAutocompleteCallback("foo")

Elimina un llamado de registro previo con el nombre name .

Parámetros

Devuelve

local ScriptEditorService = game:GetService("ScriptEditorService")

ScriptEditorService:DeregisterScriptAnalysisCallback("foo")

Devuelve el ScriptDocument abierto que coincide con el LuaSourceContainer dado, o nulo si el script dado no está abierto.

Parámetros

Devuelve

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

Devuelve la fuente de tiempo de edición para el script dado.

Si el script está abierto en el Editor de Scripts, este método devuelve el texto que se muestra actualmente en el editor. Si el script no está abierto en el editor, el método devuelve el texto que el editor mostraría si se abre. La fuente de tiempo de edición no siempre es consistente con la propiedad Script.Source .

Parámetros

Devuelve

Devuelve un arreglo de los documentos de script actualmente abiertos, incluyendo la barra de comandos.

Devuelve

--!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 retorno de llamada de autocompletado callbackFunction nombrado name con prioridad priority .

Cuando el Editor de Script invoca autocompletar, todos los registros de autocompletar se invocan de acuerdo con la prioridad creciente con la solicitud y la respuesta de autocompletar. Múltiples registros de autocompletar pueden compartir una prioridad, pero luego su orden de invocación es impredecible. Cada registro de autocompletar está destin

La función de llamada debe tener el siguiente introducir: callbackFunction a la tabla

La tabla Solicitud tiene el siguiente formato:

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

• position es la posición de cursor de un índice que estás autocompletando.
• textDocument.document es el ScriptDocument que estás completando, si existe.
• textDocument.script es el LuaSourceContainer que estás completando, si existe.

Si ambos textDocument.document y textDocument.script están presentes, entonces se corresponden entre sí: req.textDocument.document:GetScript() == req.textDocument.script

La tabla de respuesta tiene el siguiente 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 es un array de los elementos de completación. El orden de este array es insignificante, y se restablece en el editor como el tipo de usuario.
• Response.items[n].label es la etiqueta del artículo que se muestra en el menú de autocompletado.
• Response.items[n].kind especifica qué tipo de autocompletado debe mostrar este. Primero esto controla el icono dado al ítem en el editor. No todos los tipos tienen un íconoúnico. Si no se especifica, el editor usa el ícono"Texto". Los tipos no admitidos por defecto son los que se muestran en el ícono"Propiedad".
• Response.items[n].tags especifica un arreglo de etiquetas que describe este objetode completación. Vea el Enum.CompletionItemTag para obtener más información sobre su función.
• Response.items[n].details especifica una cadena que describe los detalles del objetode completación. Para los elementos por defecto, esta es una representación de tipo cadena de sus introducir. Nota que, para que el widget de la documentación se muestre, documentation debe estar presente, pero documentation.value puede estar vacío.
• Response.items[n].documentation especifica el cuerpo principal de la documentación en su campo value. documentation está presente, incluso si el valor está vacío, para que la ventana de la documentación se muestre si se especifican detalles o sobrecargas.
• Response.items[n].overloads especifica el número de overloads de una función de autocompletación.
• Response.items[n].learnMoreLink enlaces a una página relevante en los archivos de la creación. Este enlace debe ser una solicitud de https para crear.roblox.com; ningún otro enlace se muestra en el editor.
• Response.items[n].codeSample especifica un uso de muestra del objetode completación. documentation debe estar no vacío para mostrar este campo.
• Response.items[n].preselect Si es verdad, el editor clasifica este artículo de completación antes que todos los demás y lo selecciona por defecto para el usuario. Sin efecto si es falso o perdido.
• Response.items[n].textEdit Si se presenta, aceptar la terminación aplica este texto de edición - reemplazando el espacio entre las posiciones inicial y final con nuevoTexto.

Si un llamado devuelve un resultado no válido o encuentra un error, el editor descarta la tabla de respuesta modificada y usa la lista de resultados de autocompletado incorporada.

Parámetros

Devuelve

--!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 evento de análisis de guión callbackFunction nombrado name con priority . Cuando se ejecuta el análisis de guión en Studio, todos los eventos de llamada registrados se llaman en orden de prioridad ascendente. Cada evento de llamada debe devolver una tabla de respuesta que coincida con el formato especificado a continuación. Los eventos de llamada no deben producir.

La tabla de solicitudes tiene el siguiente formato, donde script es el LuaSourceContainer que se va a analizar.

type Request = {
  script: LuaSourceContainer?
}

La tabla de respuesta tiene el siguiente formato, donde diagnostics es un conjunto de tablas de diagnóstico. Cada tabla de diagnóstico tiene las entradas listadas a continuación.

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 un rango de texto que debería ser resaltado por el linter, proporcionando qué línea/carácter para comenzar a resaltar y qué línea/carácter para dejar de resaltar.
• code es una etiqueta para el mensaje.
• message es un mensaje de advertencia para mostrar para la línea. Esto también aparecerá en una herramienta cuando el usuario pase el cursor sobre la línea en el Editor de Scripts.
• severity es un valor de Enum.Severity para los diagnósticos. Esto determina cómo se categoriza el diagnóstico en la herramienta de análisis de script en Studio, así como cómo se resalta el texto en el editor de script.
• codeDescription enlaces a una página relevante en los docs del creador. Este enlace debe ser una solicitud de https a create.roblox.com; ningún otro enlace se muestra en el editor.

Parámetros

Devuelve

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)

Las solicitudes que un Editor de Script abra el script especificado. Muestra (verdadero, nulo) si la solicitud tiene éxito. Muestra (falso, cadena) si la solicitud falla, con una cadena que describe el problema.

Si la función ya está abierta, esto funciona y cambia las pestañas a la editor asociado.

Parámetros

Devuelve

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

Devuelve el tiempo de edición Script.Source para el script dado.

Esta función llama el código de llamada de devolución usado para calcular los nuevos elementos del script.

Si el script está abierto en el Editor de Scripts , entonces emite una solicitud al editor para que actualice su de origen. El editor puede rechazar esta actualización si la propiedad Script.Source estaba desactualizada con la versión del usuario cuando se llamó esta función, en cuyo caso el llamado de retorno será reinvocado y la solicitud se repetirá.

El retorno del llamado puede no ser válido. Si el llamado retorna nil , la operación se cancela. Esta función se genera hasta que se cancele o tenga éxito la operación.

Si el script no se abre en el editor, las nuevas actualizaciones de contenido se actualizan a la de origendel script, que es el texto que el editor mostraría si se abre.

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

Parámetros

Devuelve

Dispara justo después de que se cambien los ScriptDocument cambios. El textChanged es un arreglo de estructuras de cambio del 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)

Se activa justo antes de que se destruya un objeto ScriptDocument, que sucede justo después de que el editor de scripts cierre. Después de este evento, el ScriptDocument ingresa a un estado "Cerrado", y tratar de llamar sus métodos muestra un error. Los objetos de ScriptDocument no son reutilizables, incluso si el editor de scripts reabre el mismo script.

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)

Se activa justo después de que se crea y se asocie un objeto ScriptDocument y el servicio, lo cual sucede justo después de que el editor de scripts abra.

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)