1681 lines
58 KiB
JavaScript
1681 lines
58 KiB
JavaScript
(() => {
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __spreadValues = (a, b) => {
|
|
for (var prop in b || (b = {}))
|
|
if (__hasOwnProp.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
if (__getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(b)) {
|
|
if (__propIsEnum.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
}
|
|
return a;
|
|
};
|
|
var __esm = (fn, res) => function __init() {
|
|
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
|
|
};
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __async = (__this, __arguments, generator) => {
|
|
return new Promise((resolve, reject) => {
|
|
var fulfilled = (value) => {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var rejected = (value) => {
|
|
try {
|
|
step(generator.throw(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
|
|
step((generator = generator.apply(__this, __arguments)).next());
|
|
});
|
|
};
|
|
|
|
// utils/fivem.ts
|
|
var Delay, uuidv4;
|
|
var init_fivem = __esm({
|
|
"utils/fivem.ts"() {
|
|
Delay = (ms) => new Promise((res) => setTimeout(res, ms));
|
|
uuidv4 = () => {
|
|
let uuid = "";
|
|
for (let ii = 0; ii < 32; ii += 1) {
|
|
switch (ii) {
|
|
case 8:
|
|
case 20:
|
|
uuid += "-";
|
|
uuid += (Math.random() * 16 | 0).toString(16);
|
|
break;
|
|
case 12:
|
|
uuid += "-";
|
|
uuid += "4";
|
|
break;
|
|
case 16:
|
|
uuid += "-";
|
|
uuid += (Math.random() * 4 | 8).toString(16);
|
|
break;
|
|
default:
|
|
uuid += (Math.random() * 16 | 0).toString(16);
|
|
}
|
|
}
|
|
return uuid;
|
|
};
|
|
}
|
|
});
|
|
|
|
// client/cl_utils.ts
|
|
var ClientUtils, RegisterNuiCB, playerLoaded, RegisterNuiProxy, verifyExportArgType;
|
|
var init_cl_utils = __esm({
|
|
"client/cl_utils.ts"() {
|
|
init_fivem();
|
|
init_client();
|
|
ClientUtils = class {
|
|
constructor(settings) {
|
|
this._defaultSettings = {
|
|
promiseTimeout: 15e3
|
|
};
|
|
this.setSettings(settings);
|
|
}
|
|
setSettings(settings) {
|
|
this._settings = __spreadValues(__spreadValues({}, this._defaultSettings), settings);
|
|
}
|
|
emitNetPromise(eventName, ...args) {
|
|
return new Promise((resolve, reject) => {
|
|
let hasTimedOut = false;
|
|
setTimeout(() => {
|
|
hasTimedOut = true;
|
|
reject(`${eventName} has timed out after ${this._settings.promiseTimeout} ms`);
|
|
}, this._settings.promiseTimeout);
|
|
const uniqId = uuidv4();
|
|
const listenEventName = `${eventName}:${uniqId}`;
|
|
emitNet(eventName, listenEventName, ...args);
|
|
const handleListenEvent = (data) => {
|
|
removeEventListener(listenEventName, handleListenEvent);
|
|
if (hasTimedOut)
|
|
return;
|
|
resolve(data);
|
|
};
|
|
onNet(listenEventName, handleListenEvent);
|
|
});
|
|
}
|
|
};
|
|
RegisterNuiCB = (event, callback) => {
|
|
RegisterNuiCallbackType(event);
|
|
on(`__cfx_nui:${event}`, callback);
|
|
};
|
|
playerLoaded = () => {
|
|
return new Promise((resolve) => {
|
|
const id = setInterval(() => {
|
|
if (global.isPlayerLoaded)
|
|
resolve(id);
|
|
}, 50);
|
|
}).then((id) => clearInterval(id));
|
|
};
|
|
RegisterNuiProxy = (event) => {
|
|
RegisterNuiCallbackType(event);
|
|
on(`__cfx_nui:${event}`, (data, cb) => __async(void 0, null, function* () {
|
|
if (!global.isPlayerLoaded)
|
|
yield playerLoaded();
|
|
try {
|
|
const res = yield ClUtils.emitNetPromise(event, data);
|
|
cb(res);
|
|
} catch (e) {
|
|
console.error("Error encountered while listening to resp. Error:", e);
|
|
cb({ status: "error" });
|
|
}
|
|
}));
|
|
};
|
|
verifyExportArgType = (exportName, passedArg, validTypes) => {
|
|
const passedArgType = typeof passedArg;
|
|
if (!validTypes.includes(passedArgType))
|
|
throw new Error(
|
|
`Export ${exportName} was called with incorrect argument type (${validTypes.join(
|
|
", "
|
|
)}. Passed: ${passedArg}, Type: ${passedArgType})`
|
|
);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../shared/deepMergeObjects.ts
|
|
function isObject(item) {
|
|
return item && typeof item === "object" && !Array.isArray(item);
|
|
}
|
|
function deepMergeObjects(target, ...sources) {
|
|
if (!sources.length)
|
|
return target;
|
|
const source = sources.shift();
|
|
if (isObject(target) && isObject(source)) {
|
|
for (const key in source) {
|
|
if (isObject(source[key])) {
|
|
if (!target[key])
|
|
Object.assign(target, { [key]: {} });
|
|
deepMergeObjects(target[key], source[key]);
|
|
} else {
|
|
Object.assign(target, { [key]: source[key] });
|
|
}
|
|
}
|
|
}
|
|
return deepMergeObjects(target, ...sources);
|
|
}
|
|
var init_deepMergeObjects = __esm({
|
|
"../../shared/deepMergeObjects.ts"() {
|
|
}
|
|
});
|
|
|
|
// ../../config.default.json
|
|
var config_default_default;
|
|
var init_config_default = __esm({
|
|
"../../config.default.json"() {
|
|
config_default_default = {
|
|
PhoneAsItem: {
|
|
enabled: false,
|
|
exportResource: "my-core-resource",
|
|
exportFunction: "myCheckerFunction"
|
|
},
|
|
customPhoneNumber: {
|
|
enabled: false,
|
|
exportResource: "number-generator-resource",
|
|
exportFunction: "generateNumber"
|
|
},
|
|
general: {
|
|
useResourceIntegration: false,
|
|
toggleKey: "f1",
|
|
toggleCommand: "phone",
|
|
defaultLanguage: "en",
|
|
showId: false
|
|
},
|
|
contacts: {
|
|
frameworkPay: false,
|
|
payResource: "my-core-resource",
|
|
payFunction: "myCheckerFunction"
|
|
},
|
|
database: {
|
|
useIdentifierPrefix: false,
|
|
playerTable: "users",
|
|
identifierColumn: "identifier",
|
|
identifierType: "license",
|
|
profileQueries: true,
|
|
phoneNumberColumn: "phone_number"
|
|
},
|
|
images: {
|
|
url: "https://api.projecterror.dev/image",
|
|
type: "pe_image",
|
|
imageEncoding: "webp",
|
|
contentType: "multipart/form-data",
|
|
useContentType: false,
|
|
useWebhook: false,
|
|
authorizationHeader: "PE-Secret",
|
|
authorizationPrefix: "",
|
|
useAuthorization: true,
|
|
returnedDataIndexes: ["url"]
|
|
},
|
|
imageSafety: {
|
|
filterUnsafeImageUrls: true,
|
|
embedUnsafeImages: false,
|
|
embedUrl: "https://i.example.com/embed",
|
|
safeImageUrls: [
|
|
"i.imgur.com",
|
|
"i.file.glass",
|
|
"dropbox.com",
|
|
"c.tenor.com",
|
|
"discord.com",
|
|
"cdn.discordapp.com",
|
|
"media.discordapp.com",
|
|
"media.discordapp.net",
|
|
"upload.wikipedia.org",
|
|
"i.projecterror.dev",
|
|
"upcdn.io",
|
|
"i.fivemanage.com"
|
|
]
|
|
},
|
|
profanityFilter: {
|
|
enabled: false,
|
|
badWords: ["esx"]
|
|
},
|
|
twitter: {
|
|
showNotifications: true,
|
|
generateProfileNameFromUsers: true,
|
|
allowEditableProfileName: true,
|
|
allowDeleteTweets: true,
|
|
allowReportTweets: true,
|
|
allowRetweet: true,
|
|
characterLimit: 160,
|
|
newLineLimit: 10,
|
|
enableAvatars: true,
|
|
enableEmojis: true,
|
|
enableImages: true,
|
|
maxImages: 1,
|
|
allowNoMessage: false,
|
|
resultsLimit: 25
|
|
},
|
|
match: {
|
|
generateProfileNameFromUsers: true,
|
|
allowEditableProfileName: true
|
|
},
|
|
marketplace: {
|
|
persistListings: false
|
|
},
|
|
debug: {
|
|
level: "error",
|
|
enabled: true,
|
|
sentryEnabled: true
|
|
},
|
|
defaultContacts: [],
|
|
disabledApps: [],
|
|
apps: [],
|
|
voiceMessage: {
|
|
enabled: false,
|
|
authorizationHeader: "PE-Secret",
|
|
url: "",
|
|
returnedDataIndexes: ["url"]
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// client/cl_config.ts
|
|
var config;
|
|
var init_cl_config = __esm({
|
|
"client/cl_config.ts"() {
|
|
init_deepMergeObjects();
|
|
init_config_default();
|
|
config = (() => {
|
|
const resourceName = GetCurrentResourceName();
|
|
const config2 = JSON.parse(LoadResourceFile(resourceName, "config.json"));
|
|
let phoneAsItem = GetConvar("npwd:phoneAsItem", "");
|
|
if (phoneAsItem !== "") {
|
|
phoneAsItem = JSON.parse(phoneAsItem);
|
|
Object.entries(config2.PhoneAsItem).forEach(([key, value]) => {
|
|
if (phoneAsItem[key] && typeof value === typeof phoneAsItem[key]) {
|
|
config2.PhoneAsItem[key] = phoneAsItem[key];
|
|
}
|
|
});
|
|
}
|
|
return deepMergeObjects({}, config_default_default, config2);
|
|
})();
|
|
}
|
|
});
|
|
|
|
// utils/apps.ts
|
|
var apps_default;
|
|
var init_apps = __esm({
|
|
"utils/apps.ts"() {
|
|
apps_default = {
|
|
TWITTER: "TWITTER",
|
|
MATCH: "MATCH",
|
|
MESSAGES: "MESSAGES",
|
|
NOTES: "NOTES",
|
|
MARKETPLACE: "MARKETPLACE",
|
|
CONTACTS: "CONTACTS",
|
|
CAMERA: "CAMERA",
|
|
PHONE: "PHONE"
|
|
};
|
|
}
|
|
});
|
|
|
|
// utils/messages.ts
|
|
function sendMessage(app, method, data) {
|
|
return SendNUIMessage({
|
|
app,
|
|
method,
|
|
data
|
|
});
|
|
}
|
|
function sendTwitterMessage(method, data = {}) {
|
|
return sendMessage(apps_default.TWITTER, method, data);
|
|
}
|
|
function sendMessageEvent(method, data = {}) {
|
|
return sendMessage(apps_default.MESSAGES, method, data);
|
|
}
|
|
function sendNotesEvent(method, data = {}) {
|
|
return sendMessage(apps_default.NOTES, method, data);
|
|
}
|
|
function sendMarketplaceEvent(method, data = {}) {
|
|
sendMessage(apps_default.MARKETPLACE, method, data);
|
|
}
|
|
function sendContactsEvent(method, data = {}) {
|
|
sendMessage(apps_default.CONTACTS, method, data);
|
|
}
|
|
function sendCameraEvent(method, data = {}) {
|
|
sendMessage(apps_default.CAMERA, method, data);
|
|
}
|
|
function sendMatchEvent(method, data = {}) {
|
|
return sendMessage(apps_default.MATCH, method, data);
|
|
}
|
|
function sendPhoneEvent(method, data = {}) {
|
|
return sendMessage(apps_default.PHONE, method, data);
|
|
}
|
|
var init_messages = __esm({
|
|
"utils/messages.ts"() {
|
|
init_apps();
|
|
}
|
|
});
|
|
|
|
// ../../typings/phone.ts
|
|
var init_phone = __esm({
|
|
"../../typings/phone.ts"() {
|
|
}
|
|
});
|
|
|
|
// ../../typings/settings.ts
|
|
var init_settings = __esm({
|
|
"../../typings/settings.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/settings/client-kvp.service.ts
|
|
var _KvpService, KvpService, client_kvp_service_default;
|
|
var init_client_kvp_service = __esm({
|
|
"client/settings/client-kvp.service.ts"() {
|
|
_KvpService = class {
|
|
setKvp(key, value) {
|
|
SetResourceKvp(key, value);
|
|
}
|
|
setKvpFloat(key, value) {
|
|
SetResourceKvpFloat(key, value);
|
|
}
|
|
setKvpInt(key, value) {
|
|
SetResourceKvpInt(key, value);
|
|
}
|
|
getKvpString(key) {
|
|
return GetResourceKvpString(key);
|
|
}
|
|
getKvpInt(key) {
|
|
return GetResourceKvpInt(key);
|
|
}
|
|
getKvpFloat(key) {
|
|
return GetResourceKvpFloat(key);
|
|
}
|
|
};
|
|
KvpService = new _KvpService();
|
|
client_kvp_service_default = KvpService;
|
|
}
|
|
});
|
|
|
|
// client/functions.ts
|
|
function removePhoneProp() {
|
|
if (global.phoneProp != 0) {
|
|
DeleteEntity(global.phoneProp);
|
|
global.phoneProp = 0;
|
|
propCreated = false;
|
|
}
|
|
}
|
|
var propCreated, newPhoneProp;
|
|
var init_functions = __esm({
|
|
"client/functions.ts"() {
|
|
init_settings();
|
|
init_client_kvp_service();
|
|
init_fivem();
|
|
global.phoneProp = 0;
|
|
propCreated = false;
|
|
newPhoneProp = () => __async(void 0, null, function* () {
|
|
const hasNPWDProps = GetConvarInt("NPWD_PROPS", 0);
|
|
let phoneModel;
|
|
if (hasNPWDProps) {
|
|
phoneModel = "dolu_npwd_phone";
|
|
} else {
|
|
phoneModel = "prop_amb_phone";
|
|
}
|
|
removePhoneProp();
|
|
if (!propCreated) {
|
|
RequestModel(phoneModel);
|
|
while (!HasModelLoaded(phoneModel)) {
|
|
yield Delay(1);
|
|
}
|
|
const playerPed = PlayerPedId();
|
|
const [x, y, z] = GetEntityCoords(playerPed, true);
|
|
global.phoneProp = CreateObject(GetHashKey(phoneModel), x, y, z + 0.2, true, true, true);
|
|
const boneIndex = GetPedBoneIndex(playerPed, 28422);
|
|
AttachEntityToEntity(
|
|
global.phoneProp,
|
|
playerPed,
|
|
boneIndex,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
true,
|
|
true,
|
|
false,
|
|
false,
|
|
2,
|
|
true
|
|
);
|
|
propCreated = true;
|
|
let txtVariation;
|
|
if (hasNPWDProps) {
|
|
txtVariation = client_kvp_service_default.getKvpInt("npwd-frame" /* NPWD_FRAME */);
|
|
}
|
|
SetObjectTextureVariation(global.phoneProp, txtVariation || 7);
|
|
} else if (propCreated) {
|
|
console.log("prop already created");
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// client/animations/animation.service.ts
|
|
var AnimationService;
|
|
var init_animation_service = __esm({
|
|
"client/animations/animation.service.ts"() {
|
|
init_functions();
|
|
init_fivem();
|
|
AnimationService = class {
|
|
constructor() {
|
|
this.onCall = false;
|
|
this.phoneOpen = false;
|
|
this.onCamera = false;
|
|
}
|
|
createAnimationInterval() {
|
|
this.animationInterval = setInterval(() => __async(this, null, function* () {
|
|
const playerPed = PlayerPedId();
|
|
if (this.onCall) {
|
|
this.handleCallAnimation(playerPed);
|
|
} else if (this.phoneOpen && !this.onCamera) {
|
|
this.handleOpenAnimation(playerPed);
|
|
}
|
|
}), 250);
|
|
}
|
|
setPhoneState(state, stateValue) {
|
|
switch (state) {
|
|
case 0 /* ON_CALL */:
|
|
this.onCall = stateValue;
|
|
break;
|
|
case 1 /* PHONE_OPEN */:
|
|
this.phoneOpen = stateValue;
|
|
break;
|
|
case 2 /* ON_CAMERA */:
|
|
this.onCamera = stateValue;
|
|
break;
|
|
}
|
|
if (!this.onCall && !this.phoneOpen) {
|
|
if (this.animationInterval) {
|
|
clearInterval(this.animationInterval);
|
|
this.animationInterval = null;
|
|
}
|
|
} else if (!this.animationInterval) {
|
|
this.createAnimationInterval();
|
|
}
|
|
}
|
|
handleCallAnimation(playerPed) {
|
|
if (IsPedInAnyVehicle(playerPed, true)) {
|
|
this.handleOnCallInVehicle(playerPed);
|
|
} else {
|
|
this.handleOnCallNormal(playerPed);
|
|
}
|
|
}
|
|
handleOpenAnimation(playerPed) {
|
|
if (IsPedInAnyVehicle(playerPed, true)) {
|
|
this.handleOpenVehicleAnim(playerPed);
|
|
} else {
|
|
this.handleOpenNormalAnim(playerPed);
|
|
}
|
|
}
|
|
handleCallEndAnimation(playerPed) {
|
|
if (IsPedInAnyVehicle(playerPed, true)) {
|
|
this.handleCallEndVehicleAnim(playerPed);
|
|
} else {
|
|
this.handleCallEndNormalAnim(playerPed);
|
|
}
|
|
}
|
|
handleCloseAnimation(playerPed) {
|
|
if (IsPedInAnyVehicle(playerPed, true)) {
|
|
this.handleCloseVehicleAnim(playerPed);
|
|
} else {
|
|
this.handleCloseNormalAnim(playerPed);
|
|
}
|
|
}
|
|
openPhone() {
|
|
return __async(this, null, function* () {
|
|
newPhoneProp();
|
|
if (!this.onCall) {
|
|
this.handleOpenAnimation(PlayerPedId());
|
|
}
|
|
this.setPhoneState(1 /* PHONE_OPEN */, true);
|
|
});
|
|
}
|
|
closePhone() {
|
|
return __async(this, null, function* () {
|
|
removePhoneProp();
|
|
this.setPhoneState(1 /* PHONE_OPEN */, false);
|
|
if (!this.onCall) {
|
|
this.handleCloseAnimation(PlayerPedId());
|
|
}
|
|
});
|
|
}
|
|
startPhoneCall() {
|
|
return __async(this, null, function* () {
|
|
this.handleCallAnimation(PlayerPedId());
|
|
this.setPhoneState(0 /* ON_CALL */, true);
|
|
});
|
|
}
|
|
endPhoneCall() {
|
|
return __async(this, null, function* () {
|
|
this.handleCallEndAnimation(PlayerPedId());
|
|
this.setPhoneState(0 /* ON_CALL */, false);
|
|
});
|
|
}
|
|
openCamera() {
|
|
return __async(this, null, function* () {
|
|
this.setPhoneState(2 /* ON_CAMERA */, true);
|
|
});
|
|
}
|
|
closeCamera() {
|
|
return __async(this, null, function* () {
|
|
this.setPhoneState(2 /* ON_CAMERA */, false);
|
|
});
|
|
}
|
|
loadAnimDict(dict) {
|
|
return __async(this, null, function* () {
|
|
RequestAnimDict(dict);
|
|
while (!HasAnimDictLoaded(dict)) {
|
|
yield Delay(100);
|
|
}
|
|
});
|
|
}
|
|
handleOpenVehicleAnim(playerPed) {
|
|
return __async(this, null, function* () {
|
|
const dict = "anim@cellphone@in_car@ps";
|
|
const anim = "cellphone_text_in";
|
|
yield this.loadAnimDict(dict);
|
|
if (!IsEntityPlayingAnim(playerPed, dict, anim, 3)) {
|
|
SetCurrentPedWeapon(playerPed, 2725352035, true);
|
|
TaskPlayAnim(playerPed, dict, anim, 7, -1, -1, 50, 0, false, false, false);
|
|
}
|
|
});
|
|
}
|
|
handleOpenNormalAnim(playerPed) {
|
|
return __async(this, null, function* () {
|
|
const dict = "cellphone@";
|
|
const anim = "cellphone_text_in";
|
|
yield this.loadAnimDict(dict);
|
|
if (!IsEntityPlayingAnim(playerPed, dict, anim, 3)) {
|
|
SetCurrentPedWeapon(playerPed, 2725352035, true);
|
|
TaskPlayAnim(playerPed, dict, anim, 8, -1, -1, 50, 0, false, false, false);
|
|
}
|
|
});
|
|
}
|
|
handleCloseVehicleAnim(playerPed) {
|
|
return __async(this, null, function* () {
|
|
const DICT = "anim@cellphone@in_car@ps";
|
|
StopAnimTask(playerPed, DICT, "cellphone_text_in", 1);
|
|
StopAnimTask(playerPed, DICT, "cellphone_call_to_text", 1);
|
|
removePhoneProp();
|
|
});
|
|
}
|
|
handleCloseNormalAnim(playerPed) {
|
|
return __async(this, null, function* () {
|
|
const DICT = "cellphone@";
|
|
const ANIM = "cellphone_text_out";
|
|
StopAnimTask(playerPed, DICT, "cellphone_text_in", 1);
|
|
yield Delay(100);
|
|
yield this.loadAnimDict(DICT);
|
|
TaskPlayAnim(playerPed, DICT, ANIM, 7, -1, -1, 50, 0, false, false, false);
|
|
yield Delay(200);
|
|
StopAnimTask(playerPed, DICT, ANIM, 1);
|
|
removePhoneProp();
|
|
});
|
|
}
|
|
handleOnCallInVehicle(playerPed) {
|
|
return __async(this, null, function* () {
|
|
const DICT = "anim@cellphone@in_car@ps";
|
|
const ANIM = "cellphone_call_listen_base";
|
|
if (!IsEntityPlayingAnim(playerPed, DICT, ANIM, 3)) {
|
|
yield this.loadAnimDict(DICT);
|
|
TaskPlayAnim(playerPed, DICT, ANIM, 3, 3, -1, 49, 0, false, false, false);
|
|
}
|
|
});
|
|
}
|
|
handleOnCallNormal(playerPed) {
|
|
return __async(this, null, function* () {
|
|
const DICT = "cellphone@";
|
|
const ANIM = "cellphone_call_listen_base";
|
|
if (!IsEntityPlayingAnim(playerPed, DICT, ANIM, 3)) {
|
|
yield this.loadAnimDict(DICT);
|
|
TaskPlayAnim(playerPed, DICT, ANIM, 3, 3, -1, 49, 0, false, false, false);
|
|
}
|
|
});
|
|
}
|
|
handleCallEndVehicleAnim(playerPed) {
|
|
return __async(this, null, function* () {
|
|
const DICT = "anim@cellphone@in_car@ps";
|
|
const ANIM = "cellphone_call_to_text";
|
|
StopAnimTask(playerPed, DICT, "cellphone_call_listen_base", 1);
|
|
yield this.loadAnimDict(DICT);
|
|
TaskPlayAnim(playerPed, DICT, ANIM, 1.3, 5, -1, 50, 0, false, false, false);
|
|
});
|
|
}
|
|
handleCallEndNormalAnim(playerPed) {
|
|
return __async(this, null, function* () {
|
|
const DICT = "cellphone@";
|
|
const ANIM = "cellphone_call_to_text";
|
|
if (IsEntityPlayingAnim(playerPed, "cellphone@", "cellphone_call_listen_base", 49)) {
|
|
yield this.loadAnimDict(DICT);
|
|
TaskPlayAnim(playerPed, DICT, ANIM, 2.5, 8, -1, 50, 0, false, false, false);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// client/animations/animation.controller.ts
|
|
var animationService;
|
|
var init_animation_controller = __esm({
|
|
"client/animations/animation.controller.ts"() {
|
|
init_animation_service();
|
|
animationService = new AnimationService();
|
|
}
|
|
});
|
|
|
|
// client/cl_main.ts
|
|
function togglePhone() {
|
|
return __async(this, null, function* () {
|
|
const canAccess = yield checkHasPhone();
|
|
if (!canAccess)
|
|
return;
|
|
if (global.isPhoneOpen)
|
|
return yield hidePhone();
|
|
yield showPhone();
|
|
});
|
|
}
|
|
var exps, getCurrentGameTime, showPhone, hidePhone, checkHasPhone;
|
|
var init_cl_main = __esm({
|
|
"client/cl_main.ts"() {
|
|
init_messages();
|
|
init_phone();
|
|
init_cl_config();
|
|
init_animation_controller();
|
|
init_cl_utils();
|
|
global.isPhoneOpen = false;
|
|
global.isPhoneDisabled = false;
|
|
global.isPlayerLoaded = false;
|
|
global.clientPhoneNumber = null;
|
|
global.phoneProp = null;
|
|
exps = global.exports;
|
|
onNet("npwd:setPlayerLoaded" /* SET_PLAYER_LOADED */, (state) => {
|
|
global.isPlayerLoaded = state;
|
|
if (!state) {
|
|
sendMessage("PHONE", "npwd:unloadCharacter" /* UNLOAD_CHARACTER */, {});
|
|
}
|
|
});
|
|
RegisterKeyMapping(
|
|
config.general.toggleCommand,
|
|
"Åben/Luk Telefon",
|
|
"keyboard",
|
|
config.general.toggleKey
|
|
);
|
|
setTimeout(() => {
|
|
emit(
|
|
"chat:addSuggestion",
|
|
`/${config.general.toggleCommand}`,
|
|
"Vis eller gem din telefon"
|
|
);
|
|
}, 1e3);
|
|
|
|
getCurrentGameTime = () => {
|
|
setInterval(() => {
|
|
const now = new Date();
|
|
const hours = now.getHours().toString().padStart(2, '0');
|
|
const minutes = now.getMinutes().toString().padStart(2, '0');
|
|
const day = now.getDate().toString().padStart(2, '0');
|
|
const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'Maj', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dec'];
|
|
const month = now.getMonth();
|
|
const monthAbbreviation = monthNames[month];
|
|
return `${hours}:${minutes}`;
|
|
}, 1000);
|
|
};
|
|
showPhone = () => __async(void 0, null, function* () {
|
|
global.isPhoneOpen = true;
|
|
const time = getCurrentGameTime();
|
|
yield animationService.openPhone();
|
|
emitNet("npwd:getCredentials" /* FETCH_CREDENTIALS */);
|
|
SetCursorLocation(0.9, 0.922);
|
|
sendMessage("PHONE", "npwd:setVisibility" /* SET_VISIBILITY */, true);
|
|
sendMessage("PHONE", "npwd:setGameTime" /* SET_TIME */, time);
|
|
SetNuiFocus(true, true);
|
|
SetNuiFocusKeepInput(true);
|
|
emit("npwd:disableControlActions", true);
|
|
});
|
|
hidePhone = () => __async(void 0, null, function* () {
|
|
global.isPhoneOpen = false;
|
|
sendMessage("PHONE", "npwd:setVisibility" /* SET_VISIBILITY */, false);
|
|
yield animationService.closePhone();
|
|
SetNuiFocus(false, false);
|
|
SetNuiFocusKeepInput(false);
|
|
emit("npwd:disableControlActions", false);
|
|
});
|
|
RegisterCommand(
|
|
config.general.toggleCommand,
|
|
() => __async(void 0, null, function* () {
|
|
if (!global.isPhoneDisabled && !IsPauseMenuActive())
|
|
yield togglePhone();
|
|
}),
|
|
false
|
|
);
|
|
RegisterCommand(
|
|
"phone:restart",
|
|
() => __async(void 0, null, function* () {
|
|
yield hidePhone();
|
|
sendMessage("PHONE", "phoneRestart", {});
|
|
}),
|
|
false
|
|
);
|
|
checkHasPhone = () => __async(void 0, null, function* () {
|
|
if (!config.PhoneAsItem.enabled)
|
|
return true;
|
|
const exportResp = yield Promise.resolve(
|
|
exps[config.PhoneAsItem.exportResource][config.PhoneAsItem.exportFunction]()
|
|
);
|
|
if (typeof exportResp !== "number" && typeof exportResp !== "boolean") {
|
|
throw new Error("You must return either a boolean or number from your export function");
|
|
}
|
|
return !!exportResp;
|
|
});
|
|
onNet(
|
|
"npwd:sendCredentials" /* SEND_CREDENTIALS */,
|
|
(number, playerSource, playerIdentifier) => {
|
|
global.clientPhoneNumber = number;
|
|
sendMessage("SIMCARD", "npwd:setNumber" /* SET_NUMBER */, number);
|
|
sendMessage("PHONE", "npwd:sendPlayerSource" /* SEND_PLAYER_SOURCE */, playerSource);
|
|
sendMessage("PHONE", "npwd:sendPlayerIdentifier" /* SEND_PLAYER_IDENTIFIER */, playerIdentifier);
|
|
}
|
|
);
|
|
on("onResourceStop", (resource) => {
|
|
if (resource === GetCurrentResourceName()) {
|
|
sendMessage("PHONE", "npwd:setVisibility" /* SET_VISIBILITY */, false);
|
|
SetNuiFocus(false, false);
|
|
animationService.endPhoneCall();
|
|
animationService.closePhone();
|
|
ClearPedTasks(PlayerPedId());
|
|
}
|
|
});
|
|
RegisterNuiCB("npwd:close" /* CLOSE_PHONE */, (_, cb) => __async(void 0, null, function* () {
|
|
yield hidePhone();
|
|
cb();
|
|
}));
|
|
RegisterNuiCB(
|
|
"npwd:toggleAllControls" /* TOGGLE_KEYS */,
|
|
(_0, _1) => __async(void 0, [_0, _1], function* ({ keepGameFocus }, cb) {
|
|
if (global.isPhoneOpen)
|
|
SetNuiFocusKeepInput(keepGameFocus);
|
|
cb({});
|
|
})
|
|
);
|
|
if (config.PhoneAsItem.enabled) {
|
|
setTimeout(() => {
|
|
let doesExportExist = false;
|
|
const { exportResource, exportFunction } = config.PhoneAsItem;
|
|
emit(`__cfx_export_${exportResource}_${exportFunction}`, () => {
|
|
doesExportExist = true;
|
|
});
|
|
if (!doesExportExist) {
|
|
console.log("\n^1Incorrect PhoneAsItem configuration detected. Export does not exist.^0\n");
|
|
}
|
|
}, 100);
|
|
}
|
|
setInterval(() => {
|
|
const time = getCurrentGameTime();
|
|
sendMessage("PHONE", "npwd:setGameTime" /* SET_TIME */, time);
|
|
}, 2e3);
|
|
}
|
|
});
|
|
|
|
// ../../typings/twitter.ts
|
|
var init_twitter = __esm({
|
|
"../../typings/twitter.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/cl_twitter.ts
|
|
var init_cl_twitter = __esm({
|
|
"client/cl_twitter.ts"() {
|
|
init_twitter();
|
|
init_messages();
|
|
init_cl_utils();
|
|
RegisterNuiProxy("npwd:getOrCreateTwitterProfile" /* GET_OR_CREATE_PROFILE */);
|
|
RegisterNuiProxy("npwd:deleteTweet" /* DELETE_TWEET */);
|
|
RegisterNuiProxy("npwd:updateTwitterProfile" /* UPDATE_PROFILE */);
|
|
RegisterNuiProxy("npwd:createTwitterProfile" /* CREATE_PROFILE */);
|
|
RegisterNuiProxy("npwd:fetchTweets" /* FETCH_TWEETS */);
|
|
RegisterNuiProxy("npwd:createTweet" /* CREATE_TWEET */);
|
|
RegisterNuiProxy("npwd:fetchTweetsFiltered" /* FETCH_TWEETS_FILTERED */);
|
|
RegisterNuiProxy("npwd:toggleLike" /* TOGGLE_LIKE */);
|
|
RegisterNuiProxy("npwd:reportTweet" /* REPORT */);
|
|
RegisterNuiProxy("npwd:retweet" /* RETWEET */);
|
|
onNet("createTweetBroadcast" /* CREATE_TWEET_BROADCAST */, (tweet) => {
|
|
sendTwitterMessage("createTweetBroadcast" /* CREATE_TWEET_BROADCAST */, tweet);
|
|
});
|
|
onNet("npwd:tweetLikedBroadcast" /* TWEET_LIKED_BROADCAST */, (tweetId, isAddLike, likedByProfileName) => {
|
|
sendTwitterMessage("npwd:tweetLikedBroadcast" /* TWEET_LIKED_BROADCAST */, { tweetId, isAddLike, likedByProfileName });
|
|
});
|
|
onNet("npwd:deleteTweetBroadcast" /* DELETE_TWEET_BROADCAST */, (tweetId) => {
|
|
sendTwitterMessage("npwd:deleteTweetBroadcast" /* DELETE_TWEET_BROADCAST */, tweetId);
|
|
});
|
|
}
|
|
});
|
|
|
|
// ../../typings/contact.ts
|
|
var init_contact = __esm({
|
|
"../../typings/contact.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/cl_contacts.ts
|
|
var init_cl_contacts = __esm({
|
|
"client/cl_contacts.ts"() {
|
|
init_contact();
|
|
init_cl_utils();
|
|
RegisterNuiProxy("npwd-contact-pay" /* PAY_CONTACT */);
|
|
RegisterNuiProxy("npwd-contact-getAll" /* GET_CONTACTS */);
|
|
RegisterNuiProxy("npwd-contact-add" /* ADD_CONTACT */);
|
|
RegisterNuiProxy("npwd:deleteContact" /* DELETE_CONTACT */);
|
|
RegisterNuiProxy("npwd:updateContact" /* UPDATE_CONTACT */);
|
|
}
|
|
});
|
|
|
|
// ../../typings/marketplace.ts
|
|
var init_marketplace = __esm({
|
|
"../../typings/marketplace.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/cl_marketplace.ts
|
|
var init_cl_marketplace = __esm({
|
|
"client/cl_marketplace.ts"() {
|
|
init_marketplace();
|
|
init_cl_utils();
|
|
init_messages();
|
|
RegisterNuiProxy("npwd:fetchAllListings" /* FETCH_LISTING */);
|
|
RegisterNuiProxy("npwd:addListing" /* ADD_LISTING */);
|
|
RegisterNuiProxy("npwd:marketplaceDeleteListing" /* DELETE_LISTING */);
|
|
RegisterNuiProxy("npwd:reportListing" /* REPORT_LISTING */);
|
|
onNet("npwd:sendMarketplaceBroadcastAdd" /* BROADCAST_ADD */, (broadcastEvent) => {
|
|
sendMarketplaceEvent("npwd:sendMarketplaceBroadcastAdd" /* BROADCAST_ADD */, broadcastEvent);
|
|
});
|
|
onNet("npwd:sendMarketplaceBroadcastDelete" /* BROADCAST_DELETE */, (broadcastEvent) => {
|
|
sendMarketplaceEvent("npwd:sendMarketplaceBroadcastDelete" /* BROADCAST_DELETE */, broadcastEvent);
|
|
});
|
|
}
|
|
});
|
|
|
|
// ../../typings/notes.ts
|
|
var init_notes = __esm({
|
|
"../../typings/notes.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/cl_notes.ts
|
|
var init_cl_notes = __esm({
|
|
"client/cl_notes.ts"() {
|
|
init_notes();
|
|
init_cl_utils();
|
|
RegisterNuiProxy("npwd:addNote" /* ADD_NOTE */);
|
|
RegisterNuiProxy("npwd:fetchAllNotes" /* FETCH_ALL_NOTES */);
|
|
RegisterNuiProxy("npwd:updateNote" /* UPDATE_NOTE */);
|
|
RegisterNuiProxy("npwd:deleteNote" /* DELETE_NOTE */);
|
|
}
|
|
});
|
|
|
|
// ../../typings/photo.ts
|
|
var init_photo = __esm({
|
|
"../../typings/photo.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/cl_photo.ts
|
|
var require_cl_photo = __commonJS({
|
|
"client/cl_photo.ts"(exports) {
|
|
init_photo();
|
|
init_fivem();
|
|
init_messages();
|
|
init_phone();
|
|
init_client();
|
|
init_animation_controller();
|
|
init_cl_utils();
|
|
var inCameraMode = false;
|
|
var canToggleHUD = false;
|
|
var canToggleRadar = false;
|
|
function closePhoneTemp() {
|
|
SetNuiFocus(false, false);
|
|
sendMessage("PHONE", "npwd:setVisibility" /* SET_VISIBILITY */, false);
|
|
}
|
|
function openPhoneTemp() {
|
|
SetNuiFocus(true, true);
|
|
sendMessage("PHONE", "npwd:setVisibility" /* SET_VISIBILITY */, true);
|
|
}
|
|
function CellFrontCamActivate(activate) {
|
|
return Citizen.invokeNative("0x2491A93618B7D838", activate);
|
|
}
|
|
var displayHelperText = () => {
|
|
BeginTextCommandDisplayHelp("THREESTRINGS");
|
|
AddTextComponentString("Luk kamera: ~INPUT_CELLPHONE_CANCEL~");
|
|
AddTextComponentString("Skift kamera: ~INPUT_PHONE~");
|
|
AddTextComponentString("Tag billedet: ~INPUT_CELLPHONE_SELECT~");
|
|
EndTextCommandDisplayHelp(0, true, false, -1);
|
|
};
|
|
RegisterNuiCB("npwd:TakePhoto" /* TAKE_PHOTO */, (_, cb) => __async(exports, null, function* () {
|
|
yield animationService.openCamera();
|
|
emit("npwd:disableControlActions", false);
|
|
let frontCam = false;
|
|
CreateMobilePhone(1);
|
|
CellCamActivate(true, true);
|
|
closePhoneTemp();
|
|
SetNuiFocus(false, false);
|
|
inCameraMode = true;
|
|
if (!IsHudHidden()) {
|
|
canToggleHUD = true;
|
|
DisplayHud(false);
|
|
} else {
|
|
canToggleHUD = false;
|
|
}
|
|
if (!IsRadarHidden()) {
|
|
canToggleRadar = true;
|
|
DisplayRadar(false);
|
|
} else {
|
|
canToggleRadar = false;
|
|
}
|
|
emit("npwd:PhotoModeStarted" /* NPWD_PHOTO_MODE_STARTED */);
|
|
while (inCameraMode) {
|
|
yield Delay(0);
|
|
if (IsControlJustPressed(1, 27)) {
|
|
frontCam = !frontCam;
|
|
CellFrontCamActivate(frontCam);
|
|
} else if (IsControlJustPressed(1, 176)) {
|
|
const resp = yield handleTakePicture();
|
|
cb(resp);
|
|
break;
|
|
} else if (IsControlJustPressed(1, 194)) {
|
|
yield handleCameraExit();
|
|
break;
|
|
}
|
|
displayHelperText();
|
|
}
|
|
ClearHelp(true);
|
|
emit("npwd:PhotoModeEnded" /* NPWD_PHOTO_MODE_ENDED */);
|
|
emit("npwd:disableControlActions", true);
|
|
yield animationService.closeCamera();
|
|
}));
|
|
var handleTakePicture = () => __async(exports, null, function* () {
|
|
ClearHelp(true);
|
|
yield Delay(0);
|
|
const resp = yield ClUtils.emitNetPromise("npwd:UploadPhoto" /* UPLOAD_PHOTO */);
|
|
DestroyMobilePhone();
|
|
CellCamActivate(false, false);
|
|
openPhoneTemp();
|
|
animationService.openPhone();
|
|
emit("npwd:disableControlActions", true);
|
|
inCameraMode = false;
|
|
if (canToggleHUD) {
|
|
DisplayHud(true);
|
|
canToggleHUD = false;
|
|
}
|
|
if (canToggleRadar) {
|
|
DisplayRadar(true);
|
|
canToggleRadar = false;
|
|
}
|
|
return resp;
|
|
});
|
|
var handleCameraExit = () => __async(exports, null, function* () {
|
|
sendCameraEvent("npwd:cameraExited" /* CAMERA_EXITED */);
|
|
ClearHelp(true);
|
|
yield animationService.closeCamera();
|
|
emit("npwd:disableControlActions", true);
|
|
DestroyMobilePhone();
|
|
CellCamActivate(false, false);
|
|
openPhoneTemp();
|
|
inCameraMode = false;
|
|
if (canToggleHUD) {
|
|
DisplayHud(true);
|
|
canToggleHUD = false;
|
|
}
|
|
if (canToggleRadar) {
|
|
DisplayRadar(true);
|
|
canToggleRadar = false;
|
|
}
|
|
});
|
|
RegisterNuiProxy("npwd:FetchPhotos" /* FETCH_PHOTOS */);
|
|
RegisterNuiProxy("npwd:deletePhoto" /* DELETE_PHOTO */);
|
|
RegisterNuiProxy("npwd:saveImage" /* SAVE_IMAGE */);
|
|
RegisterNuiProxy("npwd:deleteMultiplePhotos" /* DELETE_MULTIPLE_PHOTOS */);
|
|
}
|
|
});
|
|
|
|
// ../../typings/messages.ts
|
|
var init_messages2 = __esm({
|
|
"../../typings/messages.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/cl_messages.ts
|
|
var init_cl_messages = __esm({
|
|
"client/cl_messages.ts"() {
|
|
init_messages2();
|
|
init_messages();
|
|
init_cl_utils();
|
|
RegisterNuiProxy("npwd:fetchMessageGroups" /* FETCH_MESSAGE_CONVERSATIONS */);
|
|
RegisterNuiProxy("npwd:deleteMessage" /* DELETE_MESSAGE */);
|
|
RegisterNuiProxy("npwd:fetchMessages" /* FETCH_MESSAGES */);
|
|
RegisterNuiProxy("npwd:createMessageGroup" /* CREATE_MESSAGE_CONVERSATION */);
|
|
RegisterNuiProxy("nwpd:deleteConversation" /* DELETE_CONVERSATION */);
|
|
RegisterNuiProxy("npwd:sendMessage" /* SEND_MESSAGE */);
|
|
RegisterNuiProxy("npwd:setReadMessages" /* SET_MESSAGE_READ */);
|
|
RegisterNuiProxy("npwd:getMessageLocation" /* GET_MESSAGE_LOCATION */);
|
|
RegisterNuiCB("npwd:setWaypoint" /* MESSAGES_SET_WAYPOINT */, ({ coords }) => {
|
|
SetNewWaypoint(coords[0], coords[1]);
|
|
});
|
|
onNet("npwd:sendMessageSuccess" /* SEND_MESSAGE_SUCCESS */, (messageDto) => {
|
|
sendMessageEvent("npwd:sendMessageSuccess" /* SEND_MESSAGE_SUCCESS */, messageDto);
|
|
});
|
|
onNet("npwd:createMessagesBroadcast" /* CREATE_MESSAGE_BROADCAST */, (result) => {
|
|
sendMessageEvent("npwd:createMessagesBroadcast" /* CREATE_MESSAGE_BROADCAST */, result);
|
|
});
|
|
onNet("npwd:createMessageConversationSuccess" /* CREATE_MESSAGE_CONVERSATION_SUCCESS */, (result) => {
|
|
sendMessageEvent("npwd:createMessageConversationSuccess" /* CREATE_MESSAGE_CONVERSATION_SUCCESS */, result);
|
|
});
|
|
}
|
|
});
|
|
|
|
// ../../typings/call.ts
|
|
var init_call = __esm({
|
|
"../../typings/call.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/sounds/client-sound.class.ts
|
|
var Sound;
|
|
var init_client_sound_class = __esm({
|
|
"client/sounds/client-sound.class.ts"() {
|
|
Sound = class {
|
|
constructor(soundName, soundSetName) {
|
|
this._soundName = soundName;
|
|
this._soundSetName = soundSetName;
|
|
this._soundId = GetSoundId();
|
|
}
|
|
play() {
|
|
PlaySoundFrontend(this._soundId, this._soundName, this._soundSetName, false);
|
|
PlaySoundFromEntity(this._soundId, this._soundName, PlayerPedId(), this._soundSetName, true, 0);
|
|
}
|
|
stop() {
|
|
StopSound(this._soundId);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// client/sounds/client-ringtone.class.ts
|
|
var Ringtone;
|
|
var init_client_ringtone_class = __esm({
|
|
"client/sounds/client-ringtone.class.ts"() {
|
|
Ringtone = class {
|
|
constructor(ringtoneName) {
|
|
this.ringtoneName = ringtoneName;
|
|
}
|
|
play() {
|
|
PlayPedRingtone(this.ringtoneName, PlayerPedId(), true);
|
|
}
|
|
stop() {
|
|
StopPedRingtone(PlayerPedId());
|
|
}
|
|
static isPlaying() {
|
|
return IsPedRingtonePlaying(PlayerPedId());
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// client/calls/cl_calls.service.ts
|
|
var exp, CallService, callService;
|
|
var init_cl_calls_service = __esm({
|
|
"client/calls/cl_calls.service.ts"() {
|
|
init_cl_main();
|
|
init_call();
|
|
init_client_sound_class();
|
|
init_client_ringtone_class();
|
|
init_settings();
|
|
init_client_kvp_service();
|
|
exp = global.exports;
|
|
CallService = class {
|
|
constructor() {
|
|
this.callSoundName = "Remote_Ring";
|
|
this.hangUpSoundName = "Hang_Up";
|
|
this.soundSet = "Phone_SoundSet_Default";
|
|
this.hangUpSoundSet = "Phone_SoundSet_Michael";
|
|
this.currentCall = 0;
|
|
}
|
|
static sendCallAction(method, data) {
|
|
SendNUIMessage({
|
|
app: "CALL",
|
|
method,
|
|
data
|
|
});
|
|
}
|
|
static sendDialerAction(method, data) {
|
|
SendNUIMessage({
|
|
app: "DIALER",
|
|
method,
|
|
data
|
|
});
|
|
}
|
|
isInCall() {
|
|
return this.currentCall !== 0;
|
|
}
|
|
isCurrentCall(tgtCall) {
|
|
return this.currentCall === tgtCall;
|
|
}
|
|
getCurrentCall() {
|
|
return this.currentPendingCall;
|
|
}
|
|
isInPendingCall() {
|
|
return !!this.currentPendingCall;
|
|
}
|
|
isCurrentPendingCall(target) {
|
|
return target === this.currentPendingCall;
|
|
}
|
|
openCallModal(show) {
|
|
CallService.sendCallAction("npwd:callModal" /* SET_CALL_MODAL */, show);
|
|
}
|
|
handleRejectCall(receiver) {
|
|
if (this.isInCall() || !this.isCurrentPendingCall(receiver))
|
|
return;
|
|
if (this.callSound)
|
|
this.callSound.stop();
|
|
if (Ringtone.isPlaying())
|
|
this.ringtone.stop();
|
|
this.currentPendingCall = null;
|
|
this.openCallModal(false);
|
|
CallService.sendCallAction("npwd:setCaller" /* SET_CALL_INFO */, null);
|
|
const hangUpSound = new Sound(this.hangUpSoundName, this.hangUpSoundSet);
|
|
hangUpSound.play();
|
|
}
|
|
handleStartCall(transmitter, receiver, isTransmitter, isUnavailable) {
|
|
return __async(this, null, function* () {
|
|
if (this.isInCall() || !(yield checkHasPhone()) || this.currentPendingCall)
|
|
return emitNet(
|
|
"npwd:rejectCall" /* REJECTED */,
|
|
{ transmitterNumber: transmitter },
|
|
1 /* BUSY_LINE */
|
|
);
|
|
this.currentPendingCall = receiver;
|
|
this.openCallModal(true);
|
|
if (isTransmitter) {
|
|
this.callSound = new Sound(this.callSoundName, this.soundSet);
|
|
this.callSound.play();
|
|
}
|
|
if (!isTransmitter) {
|
|
const ringtone = client_kvp_service_default.getKvpString("npwd-ringtone" /* NPWD_RINGTONE */);
|
|
this.ringtone = new Ringtone(ringtone);
|
|
this.ringtone.play();
|
|
}
|
|
CallService.sendCallAction("npwd:setCaller" /* SET_CALL_INFO */, {
|
|
active: true,
|
|
transmitter,
|
|
receiver,
|
|
isTransmitter,
|
|
accepted: false,
|
|
isUnavailable
|
|
});
|
|
});
|
|
}
|
|
handleCallAccepted(callData) {
|
|
this.currentCall = callData.channelId;
|
|
if (this.callSound)
|
|
this.callSound.stop();
|
|
if (Ringtone.isPlaying())
|
|
this.ringtone.stop();
|
|
exp["pma-voice"].setCallChannel(callData.channelId);
|
|
CallService.sendCallAction("npwd:setCaller" /* SET_CALL_INFO */, callData);
|
|
}
|
|
handleEndCall() {
|
|
if (this.callSound)
|
|
this.callSound.stop();
|
|
this.currentCall = 0;
|
|
exp["pma-voice"].setCallChannel(0);
|
|
this.currentPendingCall = null;
|
|
this.openCallModal(false);
|
|
CallService.sendCallAction("npwd:setCaller" /* SET_CALL_INFO */, null);
|
|
const hangUpSound = new Sound(this.hangUpSoundName, this.hangUpSoundSet);
|
|
hangUpSound.play();
|
|
}
|
|
handleMute(state, callData) {
|
|
if (state) {
|
|
exp["pma-voice"].setCallChannel(0);
|
|
} else {
|
|
exp["pma-voice"].setCallChannel(callData.channelId);
|
|
}
|
|
}
|
|
handleSendAlert(alert) {
|
|
SendNUIMessage({
|
|
app: "DIALER",
|
|
method: "npwd:callSetAlert" /* SEND_ALERT */,
|
|
data: alert
|
|
});
|
|
}
|
|
};
|
|
callService = new CallService();
|
|
}
|
|
});
|
|
|
|
// server/utils/miscUtils.ts
|
|
var onNetTyped, emitNetTyped;
|
|
var init_miscUtils = __esm({
|
|
"server/utils/miscUtils.ts"() {
|
|
onNetTyped = (eventName, cb) => onNet(eventName, cb);
|
|
emitNetTyped = (eventName, data, src) => {
|
|
if (src) {
|
|
return emitNet(eventName, src, data);
|
|
}
|
|
emitNet(eventName, data);
|
|
};
|
|
}
|
|
});
|
|
|
|
// client/calls/cl_calls.controller.ts
|
|
var initializeCallHandler;
|
|
var init_cl_calls_controller = __esm({
|
|
"client/calls/cl_calls.controller.ts"() {
|
|
init_call();
|
|
init_cl_calls_service();
|
|
init_animation_controller();
|
|
init_miscUtils();
|
|
init_cl_utils();
|
|
init_client();
|
|
initializeCallHandler = (data, cb) => __async(void 0, null, function* () {
|
|
if (callService.isInCall())
|
|
return;
|
|
try {
|
|
const serverRes = yield ClUtils.emitNetPromise(
|
|
"npwd:beginCall" /* INITIALIZE_CALL */,
|
|
data
|
|
);
|
|
animationService.startPhoneCall();
|
|
if (serverRes.status !== "ok") {
|
|
return cb == null ? void 0 : cb(serverRes);
|
|
}
|
|
const { transmitter, isTransmitter, receiver, isUnavailable } = serverRes.data;
|
|
callService.handleStartCall(transmitter, receiver, isTransmitter, isUnavailable);
|
|
cb == null ? void 0 : cb(serverRes);
|
|
} catch (e) {
|
|
console.error(e);
|
|
cb == null ? void 0 : cb({ status: "error", errorMsg: "CLIENT_TIMED_OUT" });
|
|
}
|
|
});
|
|
RegisterNuiCB("npwd:beginCall" /* INITIALIZE_CALL */, initializeCallHandler);
|
|
onNetTyped("npwd:startCall" /* START_CALL */, (data) => __async(void 0, null, function* () {
|
|
const { transmitter, isTransmitter, receiver, isUnavailable } = data;
|
|
callService.handleStartCall(transmitter, receiver, isTransmitter, isUnavailable);
|
|
}));
|
|
RegisterNuiCB("npwd:acceptCall" /* ACCEPT_CALL */, (data, cb) => {
|
|
animationService.startPhoneCall();
|
|
emitNetTyped("npwd:acceptCall" /* ACCEPT_CALL */, data);
|
|
cb({});
|
|
});
|
|
onNetTyped("npwd:callAccepted" /* WAS_ACCEPTED */, (callData) => {
|
|
callService.handleCallAccepted(callData);
|
|
});
|
|
RegisterNuiCB("npwd:rejectCall" /* REJECTED */, (data, cb) => {
|
|
emitNetTyped("npwd:rejectCall" /* REJECTED */, data);
|
|
cb({});
|
|
});
|
|
onNet("npwd:callRejected" /* WAS_REJECTED */, (currentCall) => __async(void 0, null, function* () {
|
|
callService.handleRejectCall(currentCall.receiver);
|
|
animationService.endPhoneCall();
|
|
CallService.sendDialerAction("npwd:callRejected" /* WAS_REJECTED */, currentCall);
|
|
}));
|
|
RegisterNuiCB("npwd:endCall" /* END_CALL */, (data, cb) => __async(void 0, null, function* () {
|
|
try {
|
|
const serverRes = yield ClUtils.emitNetPromise(
|
|
"npwd:endCall" /* END_CALL */,
|
|
data
|
|
);
|
|
if (serverRes.status === "error")
|
|
return console.error(serverRes.errorMsg);
|
|
cb({});
|
|
} catch (e) {
|
|
console.error(e);
|
|
cb({ status: "error", errorMsg: "CLIENT_TIMED_OUT" });
|
|
}
|
|
animationService.endPhoneCall();
|
|
}));
|
|
onNet("npwd:callEnded" /* WAS_ENDED */, (callStarter, currentCall) => {
|
|
if (callService.isInCall() && !callService.isCurrentCall(callStarter))
|
|
return;
|
|
callService.handleEndCall();
|
|
animationService.endPhoneCall();
|
|
if (currentCall) {
|
|
CallService.sendDialerAction("npwd:callRejected" /* WAS_REJECTED */, currentCall);
|
|
}
|
|
});
|
|
RegisterNuiProxy("npwd:fetchCalls" /* FETCH_CALLS */);
|
|
onNet("npwd:callSetAlert" /* SEND_ALERT */, (alert) => {
|
|
callService.handleSendAlert(alert);
|
|
});
|
|
RegisterNuiCB("npwd:toggleMuteCall" /* TOGGLE_MUTE_CALL */, (data, cb) => {
|
|
const { state, call } = data;
|
|
callService.handleMute(state, call);
|
|
cb({});
|
|
});
|
|
}
|
|
});
|
|
|
|
// ../../typings/match.ts
|
|
var init_match = __esm({
|
|
"../../typings/match.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/cl_match.ts
|
|
var init_cl_match = __esm({
|
|
"client/cl_match.ts"() {
|
|
init_match();
|
|
init_messages();
|
|
init_cl_utils();
|
|
RegisterNuiProxy("phone:getMatchProfiles" /* GET_PROFILES */);
|
|
RegisterNuiProxy("phone:getMyProfile" /* GET_MY_PROFILE */);
|
|
RegisterNuiProxy("phone:getMatches" /* GET_MATCHES */);
|
|
RegisterNuiProxy("phone:saveLikes" /* SAVE_LIKES */);
|
|
RegisterNuiProxy("phone:createMyProfile" /* CREATE_MY_PROFILE */);
|
|
RegisterNuiProxy("phone:updateMyProfile" /* UPDATE_MY_PROFILE */);
|
|
onNet("phone:saveLikesBroadcast" /* SAVE_LIKES_BROADCAST */, (result) => {
|
|
sendMatchEvent("phone:saveLikesBroadcast" /* SAVE_LIKES_BROADCAST */, result);
|
|
});
|
|
onNet("phone:matchAccountBroadcast" /* CREATE_MATCH_ACCOUNT_BROADCAST */, (result) => {
|
|
sendMatchEvent("phone:matchAccountBroadcast" /* CREATE_MATCH_ACCOUNT_BROADCAST */, result);
|
|
});
|
|
}
|
|
});
|
|
|
|
// ../../typings/darkchat.ts
|
|
var init_darkchat = __esm({
|
|
"../../typings/darkchat.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/darkchat-client.ts
|
|
var init_darkchat_client = __esm({
|
|
"client/darkchat-client.ts"() {
|
|
init_cl_utils();
|
|
init_darkchat();
|
|
init_messages();
|
|
RegisterNuiProxy("npwd:darkchatFetchChannels" /* FETCH_CHANNELS */);
|
|
RegisterNuiProxy("npwd:darkchatFetchMessages" /* FETCH_MESSAGES */);
|
|
RegisterNuiProxy("npwd:darkchatAddChannel" /* ADD_CHANNEL */);
|
|
RegisterNuiProxy("npwd:darkchatSendMessage" /* SEND_MESSAGE */);
|
|
RegisterNuiProxy("npwd:darkchatLeaveChannel" /* LEAVE_CHANNEL */);
|
|
RegisterNuiProxy("npwd:darkchatUpdateChannelLabel" /* UPDATE_CHANNEL_LABEL */);
|
|
RegisterNuiProxy("npwd:darkchatFetchMembers" /* FETCH_MEMBERS */);
|
|
RegisterNuiProxy("npwd:darkchatTransferOwnership" /* TRANSFER_OWNERSHIP */);
|
|
RegisterNuiProxy("npwd:darkchatDeleteChannel" /* DELETE_CHANNEL */);
|
|
onNet("npwd:darkchatBroadcastMessage" /* BROADCAST_MESSAGE */, (data) => {
|
|
sendMessage("DARKCHAT", "npwd:darkchatBroadcastMessage" /* BROADCAST_MESSAGE */, data);
|
|
});
|
|
onNet("npwd:darkchatBroadcastLabelUpdate" /* BROADCAST_LABEL_UPDATE */, (data) => {
|
|
sendMessage("DARKCHAT", "npwd:darkchatBroadcastLabelUpdate" /* BROADCAST_LABEL_UPDATE */, data);
|
|
});
|
|
onNet("npwd:darkchatTransferOwnershipSuccess" /* TRANSFER_OWNERSHIP_SUCCESS */, (dto) => {
|
|
sendMessage("DARKCHAT", "npwd:darkchatTransferOwnershipSuccess" /* TRANSFER_OWNERSHIP_SUCCESS */, dto);
|
|
});
|
|
onNet("npwd:darkchatDeleteChannelSuccess" /* DELETE_CHANNEL_SUCCESS */, (dto) => {
|
|
sendMessage("DARKCHAT", "npwd:darkchatDeleteChannelSuccess" /* DELETE_CHANNEL_SUCCESS */, dto);
|
|
});
|
|
}
|
|
});
|
|
|
|
// ../../typings/audio.ts
|
|
var init_audio = __esm({
|
|
"../../typings/audio.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/client-audio.ts
|
|
var init_client_audio = __esm({
|
|
"client/client-audio.ts"() {
|
|
init_cl_utils();
|
|
init_audio();
|
|
RegisterNuiProxy("npwd:audio:uploadAudio" /* UPLOAD_AUDIO */);
|
|
}
|
|
});
|
|
|
|
// ../../typings/notifications.ts
|
|
var init_notifications = __esm({
|
|
"../../typings/notifications.ts"() {
|
|
}
|
|
});
|
|
|
|
// ../../typings/alerts.ts
|
|
var init_alerts = __esm({
|
|
"../../typings/alerts.ts"() {
|
|
}
|
|
});
|
|
|
|
// client/cl_notifications.ts
|
|
var NotificationFuncRefs;
|
|
var init_cl_notifications = __esm({
|
|
"client/cl_notifications.ts"() {
|
|
init_cl_utils();
|
|
init_alerts();
|
|
init_client_kvp_service();
|
|
init_settings();
|
|
init_client_sound_class();
|
|
NotificationFuncRefs = /* @__PURE__ */ new Map();
|
|
RegisterNuiCB("npwd:playAlert" /* PLAY_ALERT */, () => {
|
|
const notifSoundset = client_kvp_service_default.getKvpString("npwd-notification" /* NPWD_NOTIFICATION */);
|
|
const sound = new Sound("Text_Arrive_Tone", notifSoundset);
|
|
sound.play();
|
|
});
|
|
RegisterNuiCB("npwd:onNotificationConfirm", (notisId, cb) => {
|
|
const funcRef = NotificationFuncRefs.get(`${notisId}:confirm`);
|
|
if (!funcRef)
|
|
return console.log(`NPWD could not find any function ref for notification: ${notisId}`);
|
|
funcRef();
|
|
NotificationFuncRefs.delete(`${notisId}:confirm`);
|
|
cb({});
|
|
});
|
|
RegisterNuiCB("npwd:onNotificationCancel", (notisId, cb) => {
|
|
const funcRef = NotificationFuncRefs.get(`${notisId}:cancel`);
|
|
if (!funcRef)
|
|
return console.log(`NPWD could not find any function ref for notification: ${notisId}`);
|
|
funcRef();
|
|
NotificationFuncRefs.delete(`${notisId}:cancel`);
|
|
cb({});
|
|
});
|
|
}
|
|
});
|
|
|
|
// client/cl_exports.ts
|
|
var require_cl_exports = __commonJS({
|
|
"client/cl_exports.ts"(exports) {
|
|
init_messages();
|
|
init_phone();
|
|
init_cl_utils();
|
|
init_cl_calls_controller();
|
|
init_contact();
|
|
init_notes();
|
|
init_cl_main();
|
|
init_client();
|
|
init_cl_calls_service();
|
|
init_animation_controller();
|
|
init_call();
|
|
init_notifications();
|
|
init_cl_notifications();
|
|
var exps2 = global.exports;
|
|
exps2("openApp", (app) => {
|
|
verifyExportArgType("openApp", app, ["string"]);
|
|
sendMessage("PHONE", "npwd:openApp" /* OPEN_APP */, app);
|
|
});
|
|
exps2("setPhoneVisible", (bool) => __async(exports, null, function* () {
|
|
verifyExportArgType("setPhoneVisible", bool, ["boolean", "number"]);
|
|
const isPhoneDisabled = global.isPhoneDisabled;
|
|
const isPhoneOpen = global.isPhoneOpen;
|
|
if (isPhoneDisabled && !bool && isPhoneOpen)
|
|
return;
|
|
const coercedType = !!bool;
|
|
if (coercedType)
|
|
yield showPhone();
|
|
else
|
|
yield hidePhone();
|
|
}));
|
|
exps2("isPhoneVisible", () => global.isPhoneOpen);
|
|
exps2("setPhoneDisabled", (bool) => {
|
|
verifyExportArgType("setPhoneVisible", bool, ["boolean", "number"]);
|
|
const coercedType = !!bool;
|
|
global.isPhoneDisabled = coercedType;
|
|
sendPhoneEvent("npwd:isPhoneDisabled" /* IS_PHONE_DISABLED */, bool);
|
|
});
|
|
exps2("isPhoneDisabled", () => global.isPhoneDisabled);
|
|
exps2("startPhoneCall", (number) => {
|
|
verifyExportArgType("startPhoneCall", number, ["string"]);
|
|
initializeCallHandler({ receiverNumber: number });
|
|
});
|
|
exps2("fillNewContact", (contactData) => {
|
|
verifyExportArgType("fillNewContact", contactData, ["object"]);
|
|
sendContactsEvent("npwd:addContactExport" /* ADD_CONTACT_EXPORT */, contactData);
|
|
});
|
|
exps2("fillNewNote", (noteData) => {
|
|
verifyExportArgType("fillNewNote", noteData, ["object"]);
|
|
sendNotesEvent("npwd:addNoteExport" /* ADD_NOTE_EXPORT */, noteData);
|
|
});
|
|
exps2("getPhoneNumber", () => __async(exports, null, function* () {
|
|
if (!global.clientPhoneNumber) {
|
|
const res = yield ClUtils.emitNetPromise("npwd:getPhoneNumber" /* GET_PHONE_NUMBER */);
|
|
global.clientPhoneNumber = res.data;
|
|
}
|
|
return global.clientPhoneNumber;
|
|
}));
|
|
exps2("isInCall", () => {
|
|
return callService.isInCall();
|
|
});
|
|
exps2("endCall", () => __async(exports, null, function* () {
|
|
if (callService.isInCall()) {
|
|
CallService.sendCallAction("npwd:endCall" /* END_CALL */, null);
|
|
animationService.endPhoneCall();
|
|
}
|
|
}));
|
|
exps2("sendUIMessage", (action) => {
|
|
SendNUIMessage(action);
|
|
});
|
|
exps2("createNotification", (dto) => {
|
|
verifyExportArgType("createSystemNotification", dto, ["object"]);
|
|
verifyExportArgType("createSystemNotification", dto.notisId, ["string"]);
|
|
sendMessage("PHONE", "npwd:createNotification" /* CREATE_NOTIFICATION */, dto);
|
|
});
|
|
exps2("createSystemNotification", (dto) => {
|
|
verifyExportArgType("createSystemNotification", dto, ["object"]);
|
|
verifyExportArgType("createSystemNotification", dto.uniqId, ["string"]);
|
|
const actionSet = dto.onConfirm || dto.onCancel;
|
|
if (dto.controls && !dto.keepOpen)
|
|
return console.log("Notification must be set to keepOpen in order to use notifcation actions");
|
|
if (!dto.controls && actionSet)
|
|
return console.log("Controls must be set to true in order to use notifcation actions");
|
|
if (dto.controls) {
|
|
NotificationFuncRefs.set(`${dto.uniqId}:confirm`, dto.onConfirm);
|
|
NotificationFuncRefs.set(`${dto.uniqId}:cancel`, dto.onCancel);
|
|
}
|
|
sendMessage("SYSTEM", "npwd:createSystemNotification" /* CREATE_SYSTEM_NOTIFICATION */, dto);
|
|
});
|
|
exps2("removeSystemNotification", (uniqId) => {
|
|
verifyExportArgType("createSystemNotification", uniqId, ["string"]);
|
|
sendMessage("SYSTEM", "npwd:removeSystemNotification" /* REMOVE_SYSTEM_NOTIFICATION */, { uniqId });
|
|
});
|
|
}
|
|
});
|
|
|
|
// client/settings/client-settings.ts
|
|
var PHONE_PROPS;
|
|
var init_client_settings = __esm({
|
|
"client/settings/client-settings.ts"() {
|
|
init_cl_utils();
|
|
init_settings();
|
|
init_client_kvp_service();
|
|
init_client_sound_class();
|
|
init_client_ringtone_class();
|
|
PHONE_PROPS = Object.freeze({
|
|
gold: 3,
|
|
default: 7,
|
|
minimal: 7,
|
|
blue: 0,
|
|
pink: 6,
|
|
white: 4
|
|
});
|
|
RegisterNuiCB("npwd:nuiSettingsUpdated" /* NUI_SETTINGS_UPDATED */, (cfg, cb) => {
|
|
global.exports["pma-voice"].setCallVolume(cfg.callVolume);
|
|
client_kvp_service_default.setKvp("npwd-ringtone" /* NPWD_RINGTONE */, cfg.ringtone.value);
|
|
client_kvp_service_default.setKvp("npwd-notification" /* NPWD_NOTIFICATION */, cfg.notiSound.value);
|
|
const frameValue = cfg.frame.value;
|
|
const frameName = frameValue.substr(0, frameValue.lastIndexOf("."));
|
|
client_kvp_service_default.setKvpInt("npwd-frame" /* NPWD_FRAME */, PHONE_PROPS[frameName]);
|
|
SetObjectTextureVariation(global.phoneProp, PHONE_PROPS[frameName]);
|
|
cb({});
|
|
});
|
|
RegisterNuiCB("npwd:previewAlert" /* PREVIEW_ALERT */, () => {
|
|
const notifSoundset = client_kvp_service_default.getKvpString("npwd-notification" /* NPWD_NOTIFICATION */);
|
|
const sound = new Sound("Text_Arrive_Tone", notifSoundset);
|
|
sound.play();
|
|
});
|
|
RegisterNuiCB("npwd:previewRingtone" /* PREVIEW_RINGTONE */, () => {
|
|
if (Ringtone.isPlaying())
|
|
return;
|
|
const ringtoneSound = client_kvp_service_default.getKvpString("npwd-ringtone" /* NPWD_RINGTONE */);
|
|
const ringtone = new Ringtone(ringtoneSound);
|
|
ringtone.play();
|
|
setTimeout(ringtone.stop, 3e3);
|
|
});
|
|
}
|
|
});
|
|
|
|
// client/client.ts
|
|
var import_cl_photo, import_cl_exports, ClUtils;
|
|
var init_client = __esm({
|
|
"client/client.ts"() {
|
|
init_cl_utils();
|
|
init_cl_config();
|
|
init_cl_main();
|
|
init_cl_twitter();
|
|
init_cl_contacts();
|
|
init_cl_marketplace();
|
|
init_cl_notes();
|
|
import_cl_photo = __toESM(require_cl_photo());
|
|
init_cl_messages();
|
|
init_cl_calls_controller();
|
|
init_cl_match();
|
|
init_darkchat_client();
|
|
init_client_audio();
|
|
init_functions();
|
|
import_cl_exports = __toESM(require_cl_exports());
|
|
init_client_settings();
|
|
init_cl_notifications();
|
|
ClUtils = new ClientUtils();
|
|
}
|
|
});
|
|
init_client();
|
|
})();
|