@iota-big3/layer-1-student-life
Version:
Layer 1 Student Life conventions for School OS - Housing, activities, wellness, and social patterns
344 lines (343 loc) • 13.8 kB
JavaScript
;
/**
* Activities Conventions for Student Life
* Manages clubs, sports, arts, and extracurricular programs
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.ActivitiesConventions = void 0;
var ActivitiesConventions;
(function (ActivitiesConventions) {
/**
* Generate balanced activity schedules
* Prevents conflicts and maximizes participation
*/
function generateActivitySchedule(activities, facilities, academicSchedule, constraints) {
const scheduledActivities = [];
const conflicts = [];
// Group activities by type and requirements
const groupedActivities = groupActivitiesByType(activities);
// Assign time slots based on priority and constraints
groupedActivities.forEach(group => {
group.activities.forEach(activity => {
const optimalSlot = findOptimalTimeSlot(activity, facilities, academicSchedule, scheduledActivities, constraints);
if (optimalSlot) {
scheduledActivities.push({
activity,
timeSlot: optimalSlot.time,
facility: optimalSlot.facility,
conflicts: optimalSlot.conflicts
});
}
else {
conflicts.push({
activity,
reason: 'No available time slot',
alternatives: suggestAlternativeSlots(activity, facilities)
});
}
});
});
return {
schedule: scheduledActivities,
conflicts,
utilization: calculateFacilityUtilization(scheduledActivities, facilities),
philosophyImpact: {
participationPotential: calculateParticipationPotential(scheduledActivities),
conflictReduction: 85, // percentage
teacherTimeOptimized: 180 // minutes per week saved
}
};
}
ActivitiesConventions.generateActivitySchedule = generateActivitySchedule;
/**
* Match students to activities based on interests and skills
* Enhances engagement and personal growth
*/
function recommendActivities(student, availableActivities, currentParticipation, peerData) {
const recommendations = [];
// Analyze student interests and strengths
const profile = analyzeStudentProfile(student, currentParticipation);
// Filter eligible activities
const eligibleActivities = availableActivities.filter(activity => meetsRequirements(student, activity) &&
hasCapacity(activity) &&
!hasScheduleConflict(activity, currentParticipation));
// Score activities based on fit
eligibleActivities.forEach(activity => {
const score = calculateActivityFit(activity, profile, peerData);
recommendations.push({
activity,
fitScore: score.overall,
reasons: score.reasons,
growthPotential: score.growthPotential,
peerParticipation: score.peerMatch
});
});
// Sort by best fit
recommendations.sort((a, b) => b.fitScore - a.fitScore);
return {
topRecommendations: recommendations.slice(0, 5),
byCategory: groupRecommendationsByCategory(recommendations),
philosophyImpact: {
engagementIncrease: 40, // percentage
skillDevelopment: calculateSkillDevelopment(recommendations),
socialConnection: 85 // score
}
};
}
ActivitiesConventions.recommendActivities = recommendActivities;
/**
* Track and optimize activity participation
* Ensures balanced involvement and prevents overcommitment
*/
function optimizeStudentPortfolio(student, currentActivities, academicPerformance, wellbeingMetrics) {
// Calculate current load
const currentLoad = calculateActivityLoad(currentActivities);
// Assess balance
const balance = assessPortfolioBalance(currentActivities, academicPerformance, wellbeingMetrics);
// Generate recommendations
const recommendations = [];
if (currentLoad.totalHours > 20) { // Weekly hours
recommendations.push({
type: 'reduce',
reason: 'Overcommitment detected',
suggestedChanges: identifyActivitiesToDrop(currentActivities),
expectedBenefit: 'Improved academic performance and wellbeing'
});
}
if (balance.diversity < 0.5) {
recommendations.push({
type: 'diversify',
reason: 'Limited activity diversity',
suggestedChanges: suggestDiversification(currentActivities),
expectedBenefit: 'Broader skill development'
});
}
if (!hasLeadershipRole(currentActivities) && student.grade >= 11) {
recommendations.push({
type: 'leadership',
reason: 'Leadership opportunity available',
suggestedChanges: identifyLeadershipOpportunities(currentActivities),
expectedBenefit: 'College readiness and personal growth'
});
}
return {
currentLoad,
balance,
recommendations,
projectedOutcomes: projectOutcomes(recommendations),
philosophyImpact: {
studentWellbeing: balance.wellbeingScore,
academicBalance: balance.academicImpact,
holisiticDevelopment: balance.diversity * 100
}
};
}
ActivitiesConventions.optimizeStudentPortfolio = optimizeStudentPortfolio;
/**
* Manage activity resources and budgets
* Optimizes allocation for maximum student benefit
*/
function allocateActivityResources(activities, totalBudget, historicalData, priorities) {
const allocations = [];
// Calculate activity impact scores
const scoredActivities = activities.map(activity => ({
activity,
impactScore: calculateActivityImpact(activity, historicalData),
costEfficiency: calculateCostEfficiency(activity, historicalData),
priorityAlignment: calculatePriorityAlignment(activity, priorities)
}));
// Sort by overall value
scoredActivities.sort((a, b) => {
const scoreA = a.impactScore * a.costEfficiency * a.priorityAlignment;
const scoreB = b.impactScore * b.costEfficiency * b.priorityAlignment;
return scoreB - scoreA;
});
// Allocate resources
let remainingBudget = totalBudget;
scoredActivities.forEach(scored => {
const requestedBudget = scored.activity.budget;
const allocation = Math.min(requestedBudget, remainingBudget, calculateMaxAllocation(scored, totalBudget));
if (allocation > 0) {
allocations.push({
activity: scored.activity,
allocatedBudget: allocation,
percentOfRequest: (allocation / requestedBudget) * 100,
justification: generateAllocationJustification(scored),
expectedOutcomes: projectActivityOutcomes(scored.activity, allocation)
});
remainingBudget -= allocation;
}
});
return {
allocations,
totalAllocated: totalBudget - remainingBudget,
unallocated: remainingBudget,
fundedActivities: allocations.length,
philosophyImpact: {
studentReach: calculateTotalStudentReach(allocations),
diversitySupported: calculateDiversityScore(allocations),
opportunityEquity: 85 // score
}
};
}
ActivitiesConventions.allocateActivityResources = allocateActivityResources;
// Helper functions
function groupActivitiesByType(activities) {
const groups = new Map();
activities.forEach(activity => {
if (!groups.has(activity.type)) {
groups.set(activity.type, []);
}
groups.get(activity.type).push(activity);
});
return Array.from(groups.entries()).map(([type, activities]) => ({
type,
activities,
priority: getTypePriority(type)
}));
}
function getTypePriority(type) {
const priorities = {
academic: 5,
leadership: 4,
service: 4,
sport: 3,
arts: 3,
club: 2
};
return priorities[type] || 1;
}
function findOptimalTimeSlot(activity, facilities, academicSchedule, scheduled, constraints) {
// Implementation would find best time slot
return null; // Placeholder
}
function suggestAlternativeSlots(activity, facilities) {
return []; // Placeholder
}
function calculateFacilityUtilization(scheduled, facilities) {
return {
overall: 75,
byFacility: new Map(),
peakTimes: [],
underutilized: []
};
}
function calculateParticipationPotential(scheduled) {
return scheduled.reduce((sum, s) => sum + s.activity.capacity.maximum, 0);
}
function analyzeStudentProfile(student, participation) {
return {
interests: [],
strengths: [],
availableTime: 10,
preferences: {}
};
}
function meetsRequirements(student, activity) {
const reqs = activity.requirements;
if (reqs.gradeLevel && !reqs.gradeLevel.includes(student.grade)) {
return false;
}
// Additional requirement checks
return true;
}
function hasCapacity(activity) {
return activity.capacity.current < activity.capacity.maximum;
}
function hasScheduleConflict(activity, participation) {
// Check for time conflicts
return false; // Placeholder
}
function calculateActivityFit(activity, profile, peerData) {
return {
overall: 85,
reasons: ['Matches interests', 'Develops new skills'],
growthPotential: 90,
peerMatch: 70
};
}
function groupRecommendationsByCategory(recommendations) {
const byCategory = new Map();
recommendations.forEach(rec => {
const category = rec.activity.category;
if (!byCategory.has(category)) {
byCategory.set(category, []);
}
byCategory.get(category).push(rec);
});
return byCategory;
}
function calculateSkillDevelopment(recommendations) {
return recommendations.slice(0, 5).reduce((sum, r) => sum + r.growthPotential, 0) / 5;
}
function calculateActivityLoad(activities) {
const totalHours = activities.reduce((sum, a) => {
// Calculate based on activity details
return sum + 5; // Placeholder
}, 0);
return {
totalHours,
byType: new Map(),
intensity: totalHours > 15 ? 'high' : totalHours > 10 ? 'medium' : 'low'
};
}
function assessPortfolioBalance(activities, academic, wellbeing) {
return {
diversity: 0.75,
academicImpact: 85,
wellbeingScore: 80,
timeBalance: 'good'
};
}
function identifyActivitiesToDrop(activities) {
// Identify lowest impact activities
return [];
}
function suggestDiversification(activities) {
return ['Add a creative activity', 'Consider community service'];
}
function hasLeadershipRole(activities) {
return activities.some(a => ['officer', 'captain', 'president'].includes(a.role));
}
function identifyLeadershipOpportunities(activities) {
return activities
.filter(a => a.attendance > 80)
.map(a => `Consider leadership role in ${a.activityId}`);
}
function projectOutcomes(recommendations) {
return {
expectedGPA: 3.8,
wellbeingImprovement: 15,
skillsGained: ['Leadership', 'Time management']
};
}
function calculateActivityImpact(activity, history) {
return 85; // Placeholder
}
function calculateCostEfficiency(activity, history) {
return 0.9; // Placeholder
}
function calculatePriorityAlignment(activity, priorities) {
return 0.8; // Placeholder
}
function calculateMaxAllocation(scored, totalBudget) {
return totalBudget * 0.1; // Max 10% per activity
}
function generateAllocationJustification(scored) {
return `High impact score (${scored.impactScore}) and strong alignment with priorities`;
}
function projectActivityOutcomes(activity, budget) {
return {
studentsServed: activity.capacity.maximum,
programsOffered: Math.floor(budget / 1000),
expectedEngagement: 85
};
}
function calculateTotalStudentReach(allocations) {
return allocations.reduce((sum, a) => sum + a.activity.capacity.maximum, 0);
}
function calculateDiversityScore(allocations) {
const types = new Set(allocations.map(a => a.activity.type));
return (types.size / 6) * 100; // 6 possible types
}
})(ActivitiesConventions || (exports.ActivitiesConventions = ActivitiesConventions = {}));