WebCraft - ремесло веб разработки

async function processImage(url) {
    const response = await fetch(url);
    const blob = await response.blob();
    const bitmap = await createImageBitmap(blob);
    console.log(bitmap.width, bitmap.height); // Лог размеров изображения
    return bitmap;
}

processImage('https://example.com/image.jpg')
    .then(bitmap => console.log('Bitmap создан:', bitmap))
    .catch(error => console.error('Ошибка:', error));

$orders = collect([
    ['id' => 1, 'date' => '2025-01-10'],
    ['id' => 2, 'date' => '2025-01-10'],
    ['id' => 3, 'date' => '2025-01-11'],
    ['id' => 4, 'date' => '2025-01-12'],
]);

$groupedOrders = $orders->chunkWhile(function ($current, $key, $collection) {
    $previous = $collection[$key - 1] ?? null;
    return $previous ? $current['date'] === $previous['date'] : true;
});

const observer = new IntersectionObserver((entries) => {
  // Стандартный callback может пропустить события
});

// Получаем все накопленные записи
const records = observer.takeRecords();
// Теперь можно обработать каждую запись, не беспокоясь о пропущенных событиях
records.forEach(record => {
  if (record.isIntersecting) {
    console.log('Элемент стал видимым:', record.target);
  }
});

use Illuminate\Database\Eloquent\LazyLoadingViolationException;
use Illuminate\Database\Eloquent\Concerns\LazyByDefault;

class Post extends Model
{
    use LazyByDefault;
    
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
}

// Теперь при обращении к comments отношение загрузится автоматически
$post = Post::find(1);
$post->comments; // Ленивая загрузка происходит здесь

const number = 1234567.89;  
const formattedNumber = number.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' });  
console.log(formattedNumber); // "1.234.567,89 €"  

const date = new Date('2024-12-31T23:59:59');  
const formattedDate = date.toLocaleString('ja-JP', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });  
console.log(formattedDate); // "火曜日, 2024年12月31日"  

class Logger {  
    private string $prefix;  

    public function __construct(string $prefix) {  
        $this->prefix = $prefix;  
    }  

    public function log(string $message): void {  
        echo "{$this->prefix}: {$message}\n";  
    }  
}  

$logger = new Logger("INFO");  
$logCallback = Closure::fromCallable([$logger, 'log']);  

$messages = ['Загрузка...', 'Данные обработаны', 'Завершено'];  
array_map($logCallback, $messages);  

const primaryAPI = new Promise((resolve, reject) =>
  setTimeout(reject, 1000, 'Primary API failed')
);
const backupAPI1 = new Promise((resolve, reject) =>
  setTimeout(resolve, 2000, 'Backup API 1 data')
);
const backupAPI2 = new Promise((resolve, reject) =>
  setTimeout(resolve, 3000, 'Backup API 2 data')
);

Promise.any([primaryAPI, backupAPI1, backupAPI2])
  .then(result => console.log('Result:', result)) // 'Result: Backup API 1 data'
  .catch(error => console.error('All failed:', error));

// Модель Post с глобальным скопом, скрывающим неопубликованные записи
class Post extends Model
{
    protected static function booted()
    {
        static::addGlobalScope('published', function ($builder) {
            $builder->where('is_published', true);
        });
    }
}

// Обычный запрос — глобальный скоп активен
$posts = Post::all(); // Вернет только опубликованные посты

// Используем queryScoped для временного включения скопа в запросе
$allPosts = Post::withoutGlobalScope('published')
    ->queryScoped('published')
    ->get();

dd($allPosts); // Вернет опубликованные записи, временно включая логику скопа

let settings = {
  database: { host: null, port: undefined },
  logging: { level: "info", enabled: undefined },
};

// Применяем значения по умолчанию
settings.database.host ??= "localhost";
settings.database.port ??= 3306;
settings.logging.enabled ??= true;

console.log(settings);
/*
{
  database: { host: "localhost", port: 3306 },
  logging: { level: "info", enabled: true }
}
*/

// Обработка вложенных структур
const config = {};
config.api?.timeout ??= 5000; // Ничего не изменит, так как config.api === undefined
console.log(config); // {}

// Активация строгого режима
use Illuminate\Database\Eloquent\Model;

Model::preventLazyLoading();

// Модель с реляцией
class Post extends Model {
    public function comments() {
        return $this->hasMany(Comment::class);
    }
}

// Попытка ленивой загрузки
$post = Post::find(1);

// Исключение, так как 'comments' не загружены явно
$post->comments;

class Post extends Model {
    protected $preventLazyLoading = true;
}

const element = document.querySelector('.resizable');
const resizeObserver = new ResizeObserver(entries => {
    for (let entry of entries) {
        const { width, height } = entry.contentRect;
        console.log(`New dimensions: ${width}x${height}`);
        element.style.backgroundColor = width > 300 ? 'lightblue' : 'lightcoral';
    }
});

// Начинаем наблюдение за изменением размеров элемента
resizeObserver.observe(element);

// Прекращаем наблюдение при необходимости
// resizeObserver.unobserve(element);
// resizeObserver.disconnect();

Route::view('/user/{id}/profile', 'user.profile', function ($id) {
    $user = User::find($id);
    return [
        'user' => $user,
        'postsCount' => $user->posts->count(),
        'profileCompleted' => $user->profile_complete
    ];
});

const threads = navigator.hardwareConcurrency || 4; // fallback на 4 потока
console.log(`Доступно потоков: ${threads}`);

const tasks = Array.from({ length: threads }, (_, i) => `Задача ${i + 1}`);

console.log('Задачи распределены:');
tasks.forEach((task, index) => {
    console.log(`Поток ${index + 1}: ${task}`);
});

protected function shouldDiscoverEvents()
{
    return true;
}

protected $listen = []; // можно оставить пустым

public function discoverEventsWithin()
{
    return [
        app_path('Listeners'),
    ];
}

const registry = new FinalizationRegistry((heldValue) => {
    console.log(`Ресурс "${heldValue}" был очищен из памяти`);
});

(function() {
    let userSession = { id: 'session_12345' };
    registry.register(userSession, 'User Session Resource');
    userSession = null; // Устанавливаем в null, чтобы позволить сборщику мусора освободить память
})();

use Illuminate\Support\Facades\Route;

Route::macro('adminRoutes', function ($callback) {
    Route::prefix('admin')
        ->namespace('Admin')
        ->middleware('auth')
        ->group($callback);
});

Route::adminRoutes(function () {
    Route::get('/dashboard', 'DashboardController@index');
    Route::resource('users', 'UserController');
});

class User {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
}

const user = Reflect.construct(User, ['Alice', 25]);
console.log(user); // User { name: 'Alice', age: 25 }

$this->app->bind(PaymentGatewayInterface::class, StripePaymentGateway::class);

$this->app->singleton(PaymentGatewayInterface::class, StripePaymentGateway::class);

const original = { name: "Alex", data: { age: 25, hobbies: ["reading", "gaming"] } };
const copy = structuredClone(original);
copy.data.age = 26;

console.log(original.data.age); // 25, оригинальный объект не изменился
console.log(copy.data.age);     // 26, независимая копия

use Illuminate\Support\Facades\URL;

$url = URL::signedRoute('user.verify', ['user' => 1]);

Route::get('/email/verify', function () {
    // действие
})->name('user.verify')->middleware('signed');

function simulateHeavyOperation() {
    console.log('Начало операции');
    queueMicrotask(() => {
        console.log('Микрозадача 1');
    });

    for (let i = 0; i < 1e6; i++) {
        if (i === 1e6 - 1) {
            console.log('Операция завершена');
        }
    }

    queueMicrotask(() => {
        console.log('Микрозадача 2');
    });

    console.log('Завершение основной задачи');
}

simulateHeavyOperation();

// Макрозадача
setTimeout(() => {
    console.log('Макрозадача');
}, 0);

$posts = Post::query()
    ->whenHas('comments', function ($query) {
        $query->where('approved', true);
    })
    ->get();

const iterableObj = {
  items: ['apple', 'banana', 'cherry'],
  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => ({
        value: this.items[index],
        done: index++ >= this.items.length
      })
    };
  }
};

for (const item of iterableObj) {
  console.log(item); // 'apple', 'banana', 'cherry'
}

use App\Models\User;
use Illuminate\Support\Facades\Event;

Event::listen('eloquent.replicating: ' . User::class, function (User $user) {
    // Очищаем уникальные поля перед копированием
    $user->email = null;
    $user->api_token = null;
});

const sym1 = Symbol('first');
const sym2 = Symbol('second');
const obj = {
  [sym1]: 'Первое значение',
  [sym2]: 'Второе значение',
  regularKey: 'Обычное свойство'
};

// Получаем все символы объекта
const symbols = Object.getOwnPropertySymbols(obj);
console.log(symbols); // [Symbol(first), Symbol(second)]

// Доступ к значению символа
console.log(obj[symbols[0]]); // 'Первое значение'

public function testLoginPageReturnsCorrectView() {
    $response = $this->get('/login');
    $response->assertViewIs('auth.login');
}

public function testAdminUserSeesAdminPanel() {
    $user = User::factory()->create(['role' => 'admin']);
    $this->actingAs($user);
    
    $response = $this->get('/dashboard');
    $response->assertViewIs('admin.panel'); // Проверка на представление для админа
}

public function testRegularUserSeesHomePage() {
    $user = User::factory()->create(['role' => 'user']);
    $this->actingAs($user);
    
    $response = $this->get('/dashboard');
    $response->assertViewIs('home'); // Проверка на представление для обычного пользователя
}

const config = { apiEndpoint: '/api', timeout: 5000 };
Object.preventExtensions(config);

// Попытка добавить новое свойство
config.retryAttempts = 3; // Не будет добавлено

console.log(config.retryAttempts); // undefined

function createImmutableConfig(options) {
  const config = { ...options };
  Object.preventExtensions(config);
  return config;
}

const appConfig = createImmutableConfig({ debug: true, version: '1.0.0' });

appConfig.newFeature = true; // Не будет добавлено
console.log(appConfig); // { debug: true, version: '1.0.0' }

use App\Models\User;
use Illuminate\Support\Facades\Event;

// Запрещаем восстановление заблокированных пользователей 
Event::listen('eloquent.restoring: ' . User::class, function (User $user) {
    if ($user->isBlocked) {
        return false;
    }
});

Event::listen('eloquent.restoring: ' . User::class, function (User $user) {
    Log::info('Попытка восстановления пользователя: ' . $user->id);
    
    if ($user->restorationAttempts >= 3) {
        $user->sendRestorationWarning(); // Отправка предупреждения при частых попытках
        return false;
    }
});