Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

fxmanifest.lua

@@ -0,0 +1,38 @@
+fx_version 'cerulean'
+game 'gta5'
+use_experimental_fxv2_oal 'yes'
+lua54 'yes'
+
+author 'ZF Labo'
+description 'A library for FiveM developers to make their life easier when using QBCore & ESX.'
+version '1.2.0'
+
+dependencies {
+ '/server:5848',
+ '/onesync',
+}
+
+files {
+ 'init.lua',
+ 'imports/**/client.lua',
+ 'imports/**/shared.lua',
+}
+
+shared_script 'modules/init.lua'
+
+shared_scripts {
+ '@ox_lib/init.lua',
+ '@es_extended/imports.lua',
+
+ 'modules/**/shared.lua',
+ 'locales.lua',
+}
+
+client_scripts {
+ 'modules/**/client.lua',
+ 'modules/**/client/*.lua'
+}
+
+server_scripts {
+ 'modules/**/server.lua',
+}

imports/require/shared.lua

@@ -0,0 +1,64 @@
+local loaded = {}
+
+package = {
+ loaded = setmetatable({}, {
+ __index = loaded,
+ __newindex = noop,
+ __metatable = false,
+ }),
+ path = './?.lua;'
+}
+
+local _require = require
+
+---Loads the given module inside the current resource, returning any values returned by the file or `true` when `nil`.
+---@param modname string
+---@return unknown?
+function zf.require(modname)
+ if type(modname) ~= 'string' then return end
+
+ local module = loaded[modname]
+
+ if not module then
+ if module == false then
+ error(("^1circular-dependency occurred when loading module '%s'^0"):format(modname), 2)
+ end
+
+ local success, result = pcall(_require, modname)
+
+ if success then
+ loaded[modname] = result
+ return result
+ end
+
+ local modpath = modname:gsub('%.', '/')
+
+ for path in package.path:gmatch('[^;]+') do
+ local scriptPath = path:gsub('?', modpath):gsub('%.+%/+', '')
+ local resourceFile = LoadResourceFile(cache.resource, scriptPath)
+
+ if resourceFile then
+ loaded[modname] = false
+ scriptPath = ('@@%s/%s'):format(cache.resource, scriptPath)
+
+ local chunk, err = load(resourceFile, scriptPath)
+
+ if err or not chunk then
+ loaded[modname] = nil
+ return error(err or ("unable to load module '%s'"):format(modname), 3)
+ end
+
+ module = chunk(modname) or true
+ loaded[modname] = module
+
+ return module
+ end
+ end
+
+ return error(("module '%s' not found"):format(modname), 2)
+ end
+
+ return module
+end
+
+return zf.require

init.lua

@@ -0,0 +1,186 @@
+local zflib = 'zf-lib'
+local export = exports[zflib]
+
+if not GetResourceState(zflib):find('start') then
+ error('^1zf-lib should be started before this resource.^0', 2)
+end
+
+
+
+-----------------------------------------------
+--------------- Module handling ---------------
+-----------------------------------------------
+local LoadResourceFile = LoadResourceFile
+local context = IsDuplicityVersion() and 'server' or 'client'
+
+function noop() end
+
+local function loadModule(self, module)
+ local dir = ('modules/%s'):format(module)
+ local chunk = LoadResourceFile(zflib, ('%s/%s.lua'):format(dir, context))
+ local shared = LoadResourceFile(zflib, ('%s/shared.lua'):format(dir))
+
+ if shared then
+ chunk = (chunk and ('%s\n%s'):format(shared, chunk)) or shared
+ end
+
+ if chunk then
+ local fn, err = load(chunk, ('@@' .. zflib .. '/%s/%s.lua'):format(module, context))
+
+ if not fn or err then
+ return error(('\n^1Error importing module (%s): %s^0'):format(dir, err), 3)
+ end
+
+ local result = fn()
+ self[module] = result or noop
+ return self[module]
+ end
+end
+
+local function call(self, index, ...)
+ local module = rawget(self, index)
+
+ if not module then
+ self[index] = noop
+ module = loadModule(self, index)
+
+ if not module then
+ local function method(...)
+ return export[index](nil, ...)
+ end
+
+ if not ... then
+ self[index] = method
+ end
+
+ return method
+ end
+ end
+
+ return module
+end
+
+zf = setmetatable({
+ name = zflib,
+ context = context
+}, {
+ __index = call,
+ __call = call,
+})
+
+require = zf.require
+
+
+
+-----------------------------------------------
+------------- Locales from QBCore -------------
+-----------------------------------------------
+Locale = {}
+Locale.__index = Locale
+
+local function translateKey(phrase, subs)
+ if type(phrase) ~= 'string' then
+ error('TypeError: translateKey function expects arg #1 to be a string')
+ end
+
+ if not subs then
+ return phrase
+ end
+
+ local result = phrase
+
+ for k, v in pairs(subs) do
+ local templateToFind = '%%{' .. k .. '}'
+ result = result:gsub(templateToFind, tostring(v)) -- string to allow all types
+ end
+
+ return result
+end
+
+function Locale.new(_, opts)
+ local self = setmetatable({}, Locale)
+
+ self.fallback = opts.fallbackLang and Locale:new({
+ warnOnMissing = false,
+ phrases = opts.fallbackLang.phrases,
+ }) or false
+
+ self.warnOnMissing = type(opts.warnOnMissing) ~= 'boolean' and true or opts.warnOnMissing
+
+ self.phrases = {}
+ self:extend(opts.phrases or {})
+
+ return self
+end
+
+function Locale:extend(phrases, prefix)
+ for key, phrase in pairs(phrases) do
+ local prefixKey = prefix and ('%s.%s'):format(prefix, key) or key
+ -- If this is a nested table, we need to go reeeeeeeeeeeecursive
+ if type(phrase) == 'table' then
+ self:extend(phrase, prefixKey)
+ else
+ self.phrases[prefixKey] = phrase
+ end
+ end
+end
+
+function Locale:clear()
+ self.phrases = {}
+end
+
+function Locale:replace(phrases)
+ phrases = phrases or {}
+ self:clear()
+ self:extend(phrases)
+end
+
+function Locale:locale(newLocale)
+ if (newLocale) then
+ self.currentLocale = newLocale
+ end
+ return self.currentLocale
+end
+
+function Locale:t(key, subs)
+ local phrase, result
+ subs = subs or {}
+
+ if type(self.phrases[key]) == 'string' then
+ phrase = self.phrases[key]
+ else
+ if self.warnOnMissing then
+ print(('^3Warning: Missing phrase for key: "%s"'):format(key))
+ end
+ if self.fallback then
+ return self.fallback:t(key, subs)
+ end
+ result = key
+ end
+
+ if type(phrase) == 'string' then
+ result = translateKey(phrase, subs)
+ end
+
+ return result
+end
+
+function Locale:has(key)
+ return self.phrases[key] ~= nil
+end
+
+function Locale:delete(phraseTarget, prefix)
+ if type(phraseTarget) == 'string' then
+ self.phrases[phraseTarget] = nil
+ else
+ for key, phrase in pairs(phraseTarget) do
+ local prefixKey = prefix and prefix .. '.' .. key or key
+
+ if type(phrase) == 'table' then
+ self:delete(phrase, prefixKey)
+ else
+ self.phrases[prefixKey] = nil
+ end
+ end
+ end
+end

modules/blip/client.lua

@@ -0,0 +1,65 @@
+Blips = {}
+JobBlips = {}
+GangBlips = {}
+
+function zf.registerBlip(coords, label, sprite, colour, scale, display)
+ local res = GetInvokingResource()
+ local blip = AddBlipForCoord(coords.x, coords.y, coords.z)
+ SetBlipSprite(blip, sprite)
+ SetBlipDisplay(blip, display)
+ SetBlipScale(blip, scale)
+ SetBlipColour(blip, colour)
+ SetBlipAsShortRange(blip, true)
+ BeginTextCommandSetBlipName("STRING")
+ AddTextComponentString(label)
+ EndTextCommandSetBlipName(blip)
+
+ if Blips[res] and Blips[res].blips then
+ Blips[res].blips[#Blips[res].blips + 1] = blip
+ else
+ Blips[res] = {}
+ Blips[res].blips = {}
+ Blips[res].blips[#Blips[res].blips + 1] = blip
+ end
+end
+
+function zf.registerJobBlip(job, coords, label, sprite, colour, scale, display)
+end
+
+function zf.registerGangBlip(gang, coords, label, sprite, colour, scale, display)
+end
+
+local function removeJobBlip()
+end
+
+local function removeGangBlip()
+end
+
+local function removeResourceBlips(resname)
+ if Blips[resname] and Blips[resname].blips then
+ for id,blip in pairs(Blips[resname].blips) do
+ RemoveBlip(blip)
+ end
+ Blips[resname] = {}
+ end
+
+ if JobBlips[resname] and JobBlips[resname].blips then
+ for id,blip in pairs(JobBlips[resname].blips) do
+ RemoveBlip(blip)
+ end
+ JobBlips[resname] = {}
+ end
+
+ if GangBlips[resname] and GangBlips[resname].blips then
+ for id,blip in pairs(GangBlips[resname].blips) do
+ RemoveBlip(blip)
+ end
+ GangBlips[resname] = {}
+ end
+end
+
+AddEventHandler('onResourceStop', function(resname)
+ if Blips[resname] or JobBlips[resname] or GangBlips[resname] then
+ removeResourceBlips(resname)
+ end
+end)